From ffe284e73ef520e7f6eb6dffad09f3e60e06383f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 6 Jul 2019 20:00:07 -0700
Subject: [PATCH 0001/2175] Added 4 solutions & modified 1 solution

---
 Easy/Defanging an IP Address.java          | 15 +++++++
 Medium/Corporate Flight Bookings.java      | 24 +++++++++++
 Medium/Delete Nodes And Return Forest.java | 50 ++++++++++++++++++++++
 Medium/Random Pick Index.java              | 21 +++++++++
 Medium/Random Pick With Weight.java        | 40 +++++++++--------
 5 files changed, 132 insertions(+), 18 deletions(-)
 create mode 100644 Easy/Defanging an IP Address.java
 create mode 100644 Medium/Corporate Flight Bookings.java
 create mode 100644 Medium/Delete Nodes And Return Forest.java
 create mode 100644 Medium/Random Pick Index.java

diff --git a/Easy/Defanging an IP Address.java b/Easy/Defanging an IP Address.java
new file mode 100644
index 00000000..06737d78
--- /dev/null
+++ b/Easy/Defanging an IP Address.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public String defangIPaddr(String address) {
+        StringBuilder sb = new StringBuilder();
+        for (char c : address.toCharArray()) {
+            if (c == '.') {
+                sb.append("[.]");
+            }
+            else {
+                sb.append(c);
+            }
+        }
+        
+        return sb.toString();
+    }
+}
diff --git a/Medium/Corporate Flight Bookings.java b/Medium/Corporate Flight Bookings.java
new file mode 100644
index 00000000..2441a222
--- /dev/null
+++ b/Medium/Corporate Flight Bookings.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int[] corpFlightBookings(int[][] bookings, int n) {
+        int[] ans = new int[n];
+
+        for (int[] booking : bookings) {
+            int tickets = booking[2];
+            int from = booking[0];
+            int to = booking[1];
+
+            ans[from - 1] += tickets;
+            if (to < n) {
+                ans[to] -= tickets;
+            }
+        }
+
+        int currSum = 0;
+        for (int i = 0; i < n; i++) {
+            currSum += ans[i];
+            ans[i] = currSum;
+        }
+
+        return ans;
+    }
+}
diff --git a/Medium/Delete Nodes And Return Forest.java b/Medium/Delete Nodes And Return Forest.java
new file mode 100644
index 00000000..8c4206cf
--- /dev/null
+++ b/Medium/Delete Nodes And Return Forest.java	
@@ -0,0 +1,50 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    List<TreeNode> forest;
+    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
+        forest = new ArrayList<>();
+        Set<Integer> toDelete = new HashSet<>();
+        for (int val : to_delete) {
+            toDelete.add(val);
+        }
+        
+        helper(root, toDelete);
+        
+        if (!toDelete.contains(root.val)) {
+            forest.add(root);
+        }
+        
+        return forest;
+    }
+    
+    private TreeNode helper(TreeNode root, Set<Integer> toDelete) {
+        if (root == null) {
+            return null;
+        }
+        
+        root.left = helper(root.left, toDelete);
+        root.right = helper(root.right, toDelete);
+        
+        if (toDelete.contains(root.val)) {
+            if (root.left != null) {
+                forest.add(root.left);
+            }
+            
+            if (root.right != null) {
+                forest.add(root.right);
+            }
+            
+            return null;
+        }
+        
+        return root;
+    }
+}
diff --git a/Medium/Random Pick Index.java b/Medium/Random Pick Index.java
new file mode 100644
index 00000000..4906e1de
--- /dev/null
+++ b/Medium/Random Pick Index.java	
@@ -0,0 +1,21 @@
+class Solution {
+    Map<Integer, List<Integer>> map = new HashMap();
+    Random rand;
+    public Solution(int[] nums) {
+        rand = new Random();
+        for (int i = 0; i < nums.length; i++) {
+            map.computeIfAbsent(nums[i], k -> new ArrayList<>()).add(i);
+        }
+    }
+    
+    public int pick(int target) {
+        List<Integer> indexes = map.get(target);
+        return indexes.get(rand.nextInt(indexes.size()));
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution obj = new Solution(nums);
+ * int param_1 = obj.pick(target);
+ */
diff --git a/Medium/Random Pick With Weight.java b/Medium/Random Pick With Weight.java
index f5924c0c..98cea2b9 100644
--- a/Medium/Random Pick With Weight.java	
+++ b/Medium/Random Pick With Weight.java	
@@ -1,33 +1,37 @@
 class Solution {
 
-    List<Integer> prefixSum;
-    int total;
-    Random rand;
+    int[] accumulatedSum;
+    Random random;
     public Solution(int[] w) {
-        prefixSum = new ArrayList<>();
-        total = 0;
-        for (int i=0; i<w.length; i++) {
-            total += w[i];
-            prefixSum.add(total);
+        random = new Random();
+        accumulatedSum = new int[w.length];
+        int currSum = 0;
+        for (int i = 0; i < w.length; i++) {
+            currSum += w[i];
+            accumulatedSum[i] = currSum;
         }
-        rand = new Random();
     }
     
     public int pickIndex() {
-        int target = rand.nextInt(total);
-        int i = 0;
-        int j = prefixSum.size() - 1;
-        while (i != j) {
-            int mid = (i+j)/2;
-            if (target >= prefixSum.get(mid)) {
-                i = mid + 1;
+        int target = random.nextInt(accumulatedSum[accumulatedSum.length - 1]) + 1;
+        return binarySearch(accumulatedSum, 0, accumulatedSum.length - 1, target);
+    }
+    
+    private int binarySearch(int[] arr, int left, int right, int target) {
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (arr[mid] == target) {
+                return mid;
+            }
+            else if (arr[mid] > target) {
+                right = mid - 1;
             }
             else {
-                j = mid;
+                left = mid + 1;
             }
         }
         
-        return j;
+        return left;
     }
 }
 

From 012e5cba3a926b22f89354d018274889d07ec049 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 8 Jul 2019 23:21:40 -0700
Subject: [PATCH 0002/2175] Added 1 solution

---
 Medium/Delete Operation for Two Strings.java | 25 ++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Delete Operation for Two Strings.java

diff --git a/Medium/Delete Operation for Two Strings.java b/Medium/Delete Operation for Two Strings.java
new file mode 100644
index 00000000..8e8f1ea5
--- /dev/null
+++ b/Medium/Delete Operation for Two Strings.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int minDistance(String word1, String word2) {
+        int[][] memo = new int[word1.length() + 1][word2.length() + 1];
+        for (int i = 0; i <= word1.length(); i++) {
+            for (int j = 0; j <= word2.length(); j++) {
+                if (i == 0) {
+                    memo[i][j] = j;
+                }
+                else if (j == 0) {
+                    memo[i][j] = i;
+                }
+                else if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
+                    memo[i][j] = memo[i - 1][j - 1];
+                }
+                else {
+                    memo[i][j] = Math.min(Math.min(memo[i - 1][j - 1] + 2, memo[i - 1][j] + 1), 
+                                          memo[i][j - 1] + 1);
+                }
+            }
+        }
+        
+        return memo[word1.length()][word2.length()];
+    }
+}
+

From 64ad1bb483cd66f58e7cbca9633e1e0304983f9d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 9 Jul 2019 18:31:06 -0700
Subject: [PATCH 0003/2175] Added 1 solution

---
 Medium/Pancake Sorting.java | 41 +++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Medium/Pancake Sorting.java

diff --git a/Medium/Pancake Sorting.java b/Medium/Pancake Sorting.java
new file mode 100644
index 00000000..a390ceb2
--- /dev/null
+++ b/Medium/Pancake Sorting.java	
@@ -0,0 +1,41 @@
+class Solution {
+    public List<Integer> pancakeSort(int[] A) {
+        List<Integer> ans = new ArrayList<>();
+        int[] copy = Arrays.copyOf(A, A.length);
+        int n = A.length - 1;
+        Arrays.sort(A);
+        int greatest = A.length - 1;
+        for (int i = 0; i < A.length; i++) {
+            int idx = findIdx(copy, A[greatest]);
+            flip(copy, idx);
+            ans.add(idx + 1);
+            flip(copy, greatest);
+            ans.add(greatest + 1);
+            greatest--;
+        }
+
+        return ans;
+    }
+
+    private void flip (int[] copy, int idx) {
+        int start = 0;
+        int end = idx;
+        while (start < end) {
+            int temp = copy[start];
+            copy[start] = copy[end];
+            copy[end] = temp;
+            start++;
+            end--;
+        }
+    }
+
+    private int findIdx (int[] arr, int target) {
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i] == target) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+}

From 68ed6210cf9b6e546602fe6cd27192c895b9d340 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 10 Jul 2019 20:56:07 -0700
Subject: [PATCH 0004/2175] Modified 2 solutions

---
 Hard/First Missing Positive.java | 35 ++++++++++++++++++--------
 Medium/Number of Islands.java    | 42 ++++++++++++++++++++------------
 2 files changed, 52 insertions(+), 25 deletions(-)

diff --git a/Hard/First Missing Positive.java b/Hard/First Missing Positive.java
index 8cdc4f6e..f08d2e95 100644
--- a/Hard/First Missing Positive.java	
+++ b/Hard/First Missing Positive.java	
@@ -1,19 +1,34 @@
 class Solution {
     public int firstMissingPositive(int[] nums) {
-        Set<Integer> set = new HashSet<>();
-        int max = 0;
+        int i = 0;
+        int n = nums.length;
+        while (i < n) {
+            // If in range 0..n & not in correct index then swap
+            if (nums[i] >= 0 && nums[i] < n && nums[nums[i]] != nums[i]) {
+                swap(nums, i, nums[i]);
+            }
+            else {
+                i++;
+            }
+        }
 
-        for (int num : nums) {
-            set.add(num);
-            max = Math.max(max, num);
+        int k = 1;
+        // Keep incrementing until the values are its correct position
+        while (k < n && nums[k] == k) {
+            k++;
         }
 
-        for (int i = 1; i <= max; i++) {
-            if (!set.contains(i)) {
-                return i;
-            }
+        // If empty array or k breaks between the end of the array
+        if (n == 0 || k < n) {
+            return k;
         }
+        
+        return nums[0] == k ? k + 1 : k;
+    }
 
-        return max + 1;
+    private void swap (int[] nums, int i, int num) {
+        int temp = nums[i];
+        nums[i] = nums[num];
+        nums[num] = temp;
     }
 }
diff --git a/Medium/Number of Islands.java b/Medium/Number of Islands.java
index 263dfdd1..fda78799 100644
--- a/Medium/Number of Islands.java	
+++ b/Medium/Number of Islands.java	
@@ -1,29 +1,41 @@
 class Solution {
+    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
     public int numIslands(char[][] grid) {
-        int count = 0;
+        if (grid.length == 0 || grid[0].length == 0) {
+            return 0;
+        }
+        
+        int countOfIslands = 0;
+        boolean[][] visited = new boolean[grid.length][grid[0].length];
+        int numOfRows = grid.length;
+        int numOfCols = grid[0].length;
         
-        for (int i=0; i<grid.length; i++) {
-            for (int j=0; j<grid[i].length; j++) {
-                if (grid[i][j] == '1') {
-                    count++;
-                    
-                    markArea(grid, i, j);
+        for (int i = 0; i < numOfRows; i++) {
+            for (int j = 0; j < numOfCols; j++) {
+                if (visited[i][j] || grid[i][j] == '0') {
+                    continue;
                 }
+                
+                dfs(grid, i, j, numOfRows, numOfCols, visited);
+                countOfIslands++;
             }
         }
         
-        return count;
+        return countOfIslands;
     }
     
-    private void markArea(char[][] grid, int i, int j) {
-        if (i < 0 || j < 0 || i >= grid.length || j >= grid[i].length || grid[i][j] == '0') {
+    private void dfs(char[][] grid, int x, int y, int numOfRows, int numOfCols, boolean[][] visited) {
+        if (x < 0 || x >= numOfRows || y < 0 || y >= numOfCols || visited[x][y]) {
+            return;
+        }
+        
+        visited[x][y] = true;
+        if (grid[x][y] == '0') {
             return;
         }
         
-        grid[i][j] = '0';
-        markArea(grid, i-1, j);
-        markArea(grid, i, j-1);
-        markArea(grid, i, j+1);
-        markArea(grid, i+1, j);
+        for (int[] dir : dirs) {
+            dfs(grid, x + dir[0], y + dir[1], numOfRows, numOfCols, visited);
+        }
     }
 }

From 13bbb63f924788e6bcccd007ef83ee7828187ecb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 11 Jul 2019 21:12:45 -0700
Subject: [PATCH 0005/2175] Added 1 solution

---
 Medium/Max Chunks To Make Sorted.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Max Chunks To Make Sorted.java

diff --git a/Medium/Max Chunks To Make Sorted.java b/Medium/Max Chunks To Make Sorted.java
new file mode 100644
index 00000000..fb401e54
--- /dev/null
+++ b/Medium/Max Chunks To Make Sorted.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int maxChunksToSorted(int[] arr) {
+        int maxSplitCount = 0;
+        int maxVal = 0;
+        int idx = 0;
+        
+        while (idx < arr.length) {
+            maxVal = Math.max(maxVal, arr[idx]);
+            if (maxVal == idx) {
+                maxSplitCount++;
+            }
+            
+            idx++;
+        }
+        
+        return maxSplitCount;
+    }
+}

From aac344141e617a9b87f3a7cfc15c4c7da7f1ba31 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 12 Jul 2019 16:40:09 -0700
Subject: [PATCH 0006/2175] Added 4 solutions & modified 2 solutions

---
 Concurrency/Print in Order.java               | 53 ++++++++++++++++++
 Easy/Flood Fill.java                          | 26 ++++-----
 Easy/Greatest Common Divisor of Strings.java  | 36 ++++++++++++
 Easy/Rotate String.java                       | 14 +----
 ...ufficient Nodes in Root to Leaf Paths.java | 25 +++++++++
 Medium/Majority Element II.java               | 56 +++++++++++++++++++
 6 files changed, 186 insertions(+), 24 deletions(-)
 create mode 100644 Concurrency/Print in Order.java
 create mode 100644 Easy/Greatest Common Divisor of Strings.java
 create mode 100644 Medium/Insufficient Nodes in Root to Leaf Paths.java
 create mode 100644 Medium/Majority Element II.java

diff --git a/Concurrency/Print in Order.java b/Concurrency/Print in Order.java
new file mode 100644
index 00000000..a23042a0
--- /dev/null
+++ b/Concurrency/Print in Order.java	
@@ -0,0 +1,53 @@
+class Foo {
+    
+    private int counter = 1;
+    private String mutex = "";
+    public Foo() {
+        
+    }
+
+    public void first(Runnable printFirst) throws InterruptedException {
+        
+        // printFirst.run() outputs "first". Do not change or remove this line.
+        boolean flag = true;
+        while (flag) {
+            synchronized(mutex) {
+                if (counter == 1) {
+                    printFirst.run();
+                    counter++;
+                    flag = false;
+                }
+            }
+        }
+    }
+
+    public void second(Runnable printSecond) throws InterruptedException {
+        
+        // printSecond.run() outputs "second". Do not change or remove this line.
+        boolean flag = true;
+        while (flag) {
+            synchronized(mutex) {
+                if (counter == 2) {
+                    printSecond.run();
+                    counter++;
+                    flag = false;
+                }
+            }
+        }
+    }
+
+    public void third(Runnable printThird) throws InterruptedException {
+        
+        // printThird.run() outputs "third". Do not change or remove this line.
+        boolean flag = true;
+        while (flag) {
+            synchronized(mutex) {
+                if (counter == 3) {
+                    printThird.run();
+                    counter++;
+                    flag = false;
+                }
+            }
+        }
+    }
+}
diff --git a/Easy/Flood Fill.java b/Easy/Flood Fill.java
index d7fe5360..38cb718e 100644
--- a/Easy/Flood Fill.java	
+++ b/Easy/Flood Fill.java	
@@ -1,20 +1,20 @@
 class Solution {
+    public int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
     public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
-        int color = image[sr][sc];
-        if (color != newColor) {
-            dfs(image, sr, sc, color, newColor);
-        }
-        
+        dfs(image, sr, sc, newColor, image[sr][sc]);
         return image;
     }
     
-    public void dfs(int[][] image, int sr, int sc, int color, int newColor) {
-        if (image[sr][sc] == color) {
-            image[sr][sc] = newColor;
-            if (sr >= 1) dfs(image, sr-1, sc, color, newColor);
-            if (sc >= 1) dfs(image, sr, sc-1, color, newColor);
-            if (sr+1 < image.length) dfs(image, sr+1, sc, color, newColor);
-            if (sc+1 < image[0].length) dfs(image, sr, sc+1, color, newColor);
+    private void dfs(int[][] image, int x, int y, int newColor, int oldColor) {
+        if(x < 0 || x >= image.length || y < 0 || y >= image[0].length || image[x][y] == newColor) {
+            return;
         }
-    } 
+        
+        if (image[x][y] == oldColor) {
+            image[x][y] = newColor;
+            for (int[] dir : dirs) {
+                dfs(image, x + dir[0], y + dir[1], newColor, oldColor);
+            }
+        }
+    }
 }
diff --git a/Easy/Greatest Common Divisor of Strings.java b/Easy/Greatest Common Divisor of Strings.java
new file mode 100644
index 00000000..3a08a29f
--- /dev/null
+++ b/Easy/Greatest Common Divisor of Strings.java	
@@ -0,0 +1,36 @@
+class Solution {
+    public String gcdOfStrings(String str1, String str2) {
+        return stringGcd(str1, str2);
+    }
+    
+    private String stringGcd(String s1, String s2) {
+        if (s1.length() == 0) {
+            return s2;
+        }
+        
+        if (s2.length() == 0) {
+            return s1;
+        }
+        
+        if (s1.equals(s2)) {
+            return s1;
+        }
+        
+        if (s1.length() > s2.length()) {
+            for (int i = 0; i < s2.length(); i++) {
+                if (s1.charAt(i) != s2.charAt(i)) {
+                    return "";
+                }
+            }
+            
+            String temp = s1.substring(s2.length());
+            return stringGcd(temp, s2);
+        }
+        
+        if (s2.length() > s1.length()) {
+            return stringGcd(s2, s1);
+        }
+        
+        return "";
+    }
+}
diff --git a/Easy/Rotate String.java b/Easy/Rotate String.java
index 28c0f5dd..38b31492 100644
--- a/Easy/Rotate String.java	
+++ b/Easy/Rotate String.java	
@@ -1,17 +1,9 @@
 class Solution {
     public boolean rotateString(String A, String B) {
-        if (A.isEmpty() && B.isEmpty()) return true;
-        int n = A.length();
-        int shiftCount = 0;
-        
-        while(shiftCount < n) {
-            if (A.equals(B)) {
-                return true;
-            }
-            A = A.substring(1, n) + A.substring(0,1);
-            shiftCount++;
+        if (A.length() != B.length()) {
+            return false;
         }
         
-        return false;
+        return (A + A).contains(B);
     }
 }
diff --git a/Medium/Insufficient Nodes in Root to Leaf Paths.java b/Medium/Insufficient Nodes in Root to Leaf Paths.java
new file mode 100644
index 00000000..84f8682b
--- /dev/null
+++ b/Medium/Insufficient Nodes in Root to Leaf Paths.java	
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode sufficientSubset(TreeNode root, int limit) {
+        if (root == null) {
+            return null;
+        }
+        
+        if (root.left == null && root.right == null) {
+            return root.val < limit ? null : root;
+        }
+        
+        root.left = sufficientSubset(root.left, limit - root.val);
+        root.right = sufficientSubset(root.right, limit - root.val);
+        
+        return root.left == root.right ? null : root;
+    }
+}
diff --git a/Medium/Majority Element II.java b/Medium/Majority Element II.java
new file mode 100644
index 00000000..dcbe0102
--- /dev/null
+++ b/Medium/Majority Element II.java	
@@ -0,0 +1,56 @@
+class Solution {
+    public List<Integer> majorityElement(int[] nums) {
+        if (nums.length == 0) {
+            return new ArrayList<>();
+        }
+        
+        int num1 = nums[0];
+        int num2 = nums[0];
+        int count1 = 0;
+        int count2 = 0;
+        
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == num1) {
+                count1++;
+            }
+            else if (nums[i] == num2) {
+                count2++;
+            }
+            else if (count1 == 0) {
+                num1 = nums[i];
+                count1 = 1;
+            }
+            else if (count2 == 0) {
+                num2 = nums[i];
+                count2 = 1;
+            }
+            else {
+                count1--;
+                count2--;
+            }
+        }
+        
+        count1 = 0;
+        count2 = 0;
+        
+        for (int i = 0; i< nums.length; i++) {
+            if (nums[i] == num1) {
+                count1++;
+            }
+            else if (nums[i] == num2) {
+                count2++;
+            }
+        }
+        
+        List<Integer> ans = new ArrayList<>();
+        if (count1 > nums.length / 3) {
+            ans.add(num1);
+        }
+        
+        if (count2 > nums.length / 3) {
+            ans.add(num2);
+        }
+        
+        return ans;
+    }
+}

From 292033dca56a1964d3c4660033e9243de778e9c9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 13 Jul 2019 09:41:37 -0700
Subject: [PATCH 0007/2175] Added 3 solutions

---
 Easy/Number of Days in a Month.java   | 24 +++++++++++
 Easy/Remove Vowels from a String.java | 14 ++++++
 Medium/Maximum Average Subtree.java   | 62 +++++++++++++++++++++++++++
 3 files changed, 100 insertions(+)
 create mode 100644 Easy/Number of Days in a Month.java
 create mode 100644 Easy/Remove Vowels from a String.java
 create mode 100644 Medium/Maximum Average Subtree.java

diff --git a/Easy/Number of Days in a Month.java b/Easy/Number of Days in a Month.java
new file mode 100644
index 00000000..5ef06149
--- /dev/null
+++ b/Easy/Number of Days in a Month.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int numberOfDays(int Y, int M) {
+        int[] arr = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+        if (M == 2) {
+            return isLeapYear(Y) ? arr[M - 1] + 1 : arr[M - 1];
+        }
+
+        return arr[M- 1];
+    }
+
+    private boolean isLeapYear (int y) {
+        if (y % 4  == 0) {
+            if (y % 100 == 0) {
+                return y % 400 == 0;
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+}
diff --git a/Easy/Remove Vowels from a String.java b/Easy/Remove Vowels from a String.java
new file mode 100644
index 00000000..f389ac47
--- /dev/null
+++ b/Easy/Remove Vowels from a String.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public String removeVowels(String S) {
+        StringBuilder sb = new StringBuilder();
+        Set<Character> set = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u'));
+        
+        for (char c : S.toCharArray()) {
+            if (!set.contains(c)) {
+                sb.append(c);
+            }
+        }
+        
+        return sb.toString();
+    }
+}
diff --git a/Medium/Maximum Average Subtree.java b/Medium/Maximum Average Subtree.java
new file mode 100644
index 00000000..c422844b
--- /dev/null
+++ b/Medium/Maximum Average Subtree.java	
@@ -0,0 +1,62 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    Map<TreeNode, Integer> sumMap = new HashMap<>();
+    Map<TreeNode, Integer> numNodesMap = new HashMap<>();
+    double maxAvg = -1.0;
+    public double maximumAverageSubtree(TreeNode root) {
+        dfs(root);
+        return maxAvg;
+    }
+    
+    private void dfs(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        
+        int sum = getSum(root);
+        int nodes = getNumOfNodes(root);
+        
+        maxAvg = Math.max(maxAvg, ((double) (sum) / nodes));
+        
+        dfs(root.left);
+        dfs(root.right);
+    }
+    
+    private int getSum(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        
+        if (sumMap.containsKey(root)) {
+            return sumMap.get(root);
+        }
+        
+        int sum = root.val + getSum(root.left) + getSum(root.right);
+        sumMap.put(root, sum);
+        
+        return sum;
+    }
+    
+    private int getNumOfNodes(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        
+        if (numNodesMap.containsKey(root)) {
+            return numNodesMap.get(root);
+        }
+        
+        int numNodes = 1 + getNumOfNodes(root.left) + getNumOfNodes(root.right);
+        numNodesMap.put(root, numNodes);
+        
+        return numNodes;
+    }
+}

From b6f9ddaf95bdd92bcaeaecefcfa55b1caf450719 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 13 Jul 2019 20:16:40 -0700
Subject: [PATCH 0008/2175] Added 2 solutions

---
 Easy/Relative Sort Array.java                 | 41 +++++++++++++++++++
 ...ivide Array Into Increasing Sequences.java | 23 +++++++++++
 2 files changed, 64 insertions(+)
 create mode 100644 Easy/Relative Sort Array.java
 create mode 100644 Hard/Divide Array Into Increasing Sequences.java

diff --git a/Easy/Relative Sort Array.java b/Easy/Relative Sort Array.java
new file mode 100644
index 00000000..00869ab1
--- /dev/null
+++ b/Easy/Relative Sort Array.java	
@@ -0,0 +1,41 @@
+class Solution {
+    public int[] relativeSortArray(int[] A1, int[] A2) {
+        Map<Integer, Integer> a2Map = new LinkedHashMap<>();
+        Map<Integer, Integer> a1Map = new HashMap<>();
+        int idx = 0;
+        for (int num : A2) {
+            if (!a2Map.containsKey(num)) {
+                a2Map.put(num, idx++);
+            }
+        }
+
+        for (int num : A1) {
+            a1Map.put(num, a1Map.getOrDefault(num, 0) + 1);
+        }
+
+        int i = 0;
+        for (Integer key : a2Map.keySet()) {
+            int count = a1Map.getOrDefault(key, 0);
+            while (count-- > 0) {
+                A1[i++] = key;
+            }
+            
+            a1Map.remove(key);
+        }
+
+        List<Integer> leftOver = new ArrayList<>();
+        for (Integer key : a1Map.keySet()) {
+            int count = a1Map.get(key);
+            while (count-- > 0) {
+                leftOver.add(key);
+            }
+        }
+
+        Collections.sort(leftOver);
+        for (int num : leftOver) {
+            A1[i++] = num;
+        }
+        
+        return A1;
+    }
+}
diff --git a/Hard/Divide Array Into Increasing Sequences.java b/Hard/Divide Array Into Increasing Sequences.java
new file mode 100644
index 00000000..5e93803c
--- /dev/null
+++ b/Hard/Divide Array Into Increasing Sequences.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public boolean canDivideIntoSubsequences(int[] nums, int K) {
+        int maxCount = 1;
+        int count = 1;
+        int idx = 1;
+        int n = nums.length;
+        while (idx < n) {
+            if (nums[idx] == nums[idx - 1]) {
+                count++;
+            }
+            else {
+                maxCount = Math.max(maxCount, count);
+                count = 1;
+            }
+            
+            idx++;
+        }
+        
+        maxCount = Math.max(maxCount, count);
+        
+        return nums.length >= maxCount * K;
+    }
+}

From 6db25729e56742602734fdc9ddae1fa225bb5001 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 14 Jul 2019 07:53:25 -0700
Subject: [PATCH 0009/2175] Added 2 solutions

---
 Medium/Longest Well-Performing Interval.java  | 27 ++++++++++++
 ...est Common Ancestor of Deepest Leaves.java | 43 +++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 Medium/Longest Well-Performing Interval.java
 create mode 100644 Medium/Lowest Common Ancestor of Deepest Leaves.java

diff --git a/Medium/Longest Well-Performing Interval.java b/Medium/Longest Well-Performing Interval.java
new file mode 100644
index 00000000..145e39d5
--- /dev/null
+++ b/Medium/Longest Well-Performing Interval.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int longestWPI(int[] hours) {
+        int ans = 0;
+        int[] preComputed = new int[hours.length + 1];
+        
+        for (int i = 1; i < preComputed.length; i++) {
+            if (hours[i - 1] > 8) {
+                ans = 1;
+                preComputed[i] = preComputed[i - 1] + 1;
+            }
+            else {
+                preComputed[i] = preComputed[i - 1] - 1;
+            }
+        }
+        
+        for(int i = 0; i <= hours.length; i++){
+            for(int j = hours.length; j > i; j--){
+                if(preComputed[j]-preComputed[i] > 0){
+                    ans = Math.max(ans, j - i);
+                    break;
+                }
+            }
+        }
+        
+        return ans;
+    }
+}
diff --git a/Medium/Lowest Common Ancestor of Deepest Leaves.java b/Medium/Lowest Common Ancestor of Deepest Leaves.java
new file mode 100644
index 00000000..4517a201
--- /dev/null
+++ b/Medium/Lowest Common Ancestor of Deepest Leaves.java	
@@ -0,0 +1,43 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {    
+    public TreeNode lcaDeepestLeaves(TreeNode root) {
+        return helper(root).lowesetCommonAncestor;
+    }
+    
+    private UpdatedTreeNode helper(TreeNode root) {       
+        if (root == null) {
+            return new UpdatedTreeNode(0, null);
+        }
+        
+        UpdatedTreeNode leftUpdated = helper(root.left);
+        UpdatedTreeNode rightUpdated = helper(root.right);
+        
+        if (leftUpdated.depth == rightUpdated.depth) {
+            return new UpdatedTreeNode(leftUpdated.depth + 1, root);
+        }
+        else if (leftUpdated.depth > rightUpdated.depth) {
+            return new UpdatedTreeNode(leftUpdated.depth + 1, leftUpdated.lowesetCommonAncestor);
+        }
+        else {
+            return new UpdatedTreeNode(rightUpdated.depth + 1, rightUpdated.lowesetCommonAncestor);
+        }
+    }
+}
+
+class UpdatedTreeNode {
+    public int depth;
+    public TreeNode lowesetCommonAncestor;
+
+    public UpdatedTreeNode(int depth, TreeNode node) {
+        this.depth = depth;
+        this.lowesetCommonAncestor = node;
+    }
+}

From 098c75aa05d20828d00c6cd8d60fcd700309c4f5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 15 Jul 2019 19:45:53 -0700
Subject: [PATCH 0010/2175] Added 4 solutions

---
 ...ber of Submatrices That Sum to Target.java | 29 ++++++++
 Medium/Missing Element in Sorted Array.java   | 26 +++++++
 Medium/Range Sum Query - Mutable.java         | 71 +++++++++++++++++++
 Medium/Uncrossed Lines.java                   | 25 +++++++
 4 files changed, 151 insertions(+)
 create mode 100644 Hard/Number of Submatrices That Sum to Target.java
 create mode 100644 Medium/Missing Element in Sorted Array.java
 create mode 100644 Medium/Range Sum Query - Mutable.java
 create mode 100644 Medium/Uncrossed Lines.java

diff --git a/Hard/Number of Submatrices That Sum to Target.java b/Hard/Number of Submatrices That Sum to Target.java
new file mode 100644
index 00000000..edd19f0d
--- /dev/null
+++ b/Hard/Number of Submatrices That Sum to Target.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int numSubmatrixSumTarget(int[][] matrix, int target) {
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+        int res = 0;
+        
+        for (int i = 0; i < rows; i++) {
+            for (int j = 1; j < cols; j++) {
+                matrix[i][j] += matrix[i][j - 1];
+            }
+        }
+        
+        for (int i = 0; i < cols; i++) {
+            for (int j = i; j < cols; j++) {
+                Map<Integer, Integer> map = new HashMap<>();
+                map.put(0, 1);
+                int sum = 0;
+                for (int k = 0; k < rows; k++) {
+                    sum += matrix[k][j] - (i > 0 ? matrix[k][i - 1] : 0);
+                    res += map.getOrDefault(sum - target, 0);
+                    
+                    map.put(sum, map.getOrDefault(sum, 0) + 1);
+                }
+            }
+        }
+        
+        return res;
+    }
+}
diff --git a/Medium/Missing Element in Sorted Array.java b/Medium/Missing Element in Sorted Array.java
new file mode 100644
index 00000000..d9d8beb2
--- /dev/null
+++ b/Medium/Missing Element in Sorted Array.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int missingElement(int[] nums, int k) {
+        int idx = 0;
+        while (idx < nums.length - 1) {
+            if (nums[idx] != nums[idx + 1] - 1) {
+                int diff = nums[idx + 1] - nums[idx] - 1;
+                if (diff >= k) {
+                    int step = nums[idx] + 1;
+                    while (k > 1) {
+                        step++;
+                        k--;
+                    }
+                    
+                    return step;
+                }
+                else {
+                    k -= diff;
+                }
+            }
+            
+            idx++;
+        }
+        
+        return nums[nums.length - 1] + k;
+    }
+}
diff --git a/Medium/Range Sum Query - Mutable.java b/Medium/Range Sum Query - Mutable.java
new file mode 100644
index 00000000..0ff8bbbb
--- /dev/null
+++ b/Medium/Range Sum Query - Mutable.java	
@@ -0,0 +1,71 @@
+class NumArray {
+    int[] fen;
+    int[] nums;
+    int n;
+    public NumArray(int[] nums) {
+        this.nums = nums;
+        n = nums.length;
+        fen = new int[n + 1];
+        init();
+    }
+
+    private void init () {
+        if (n == 0) {
+            return;
+        }
+
+        // Compute the pre-sum
+        fen[1] = nums[0];
+        for (int i = 1; i < n; i++) {
+            fen[i + 1] = fen[i] + nums[i];
+        }
+
+        for (int i = n; i > 0; i--) {
+            // Removing the value of parent for each node
+            int parent = i - (i & -i);
+            if (parent >= 0) {
+                fen[i] -= fen[parent];
+            }
+        }
+    }
+
+    public void update(int i, int val) {
+        // Find the difference between previous and current value
+        int extra = val - nums[i];
+
+        // Update the actual array with the new val
+        nums[i] = val;
+
+        // Update the tree with the extra value to all the parents 
+        increment(i, extra);
+    }
+
+    private void increment (int i, int extra) {
+        i++;
+        while (i <= n) {
+            fen[i] += extra;
+            i = i + (i & -i);
+        }
+    }
+
+    public int sumRange(int i, int j) {
+        // Similar to pre sum from 0 to j - pre sum from 0 to i
+        return getSum(j + 1) - getSum(i);
+    }
+
+    private int getSum (int i) {
+        int res = 0;
+        while (i > 0) {
+            res += fen[i];
+            i = i - (i & -i);
+        }
+
+        return res;
+    }
+}
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * obj.update(i,val);
+ * int param_2 = obj.sumRange(i,j);
+ */
diff --git a/Medium/Uncrossed Lines.java b/Medium/Uncrossed Lines.java
new file mode 100644
index 00000000..362e6606
--- /dev/null
+++ b/Medium/Uncrossed Lines.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int maxUncrossedLines(int[] A, int[] B) {
+        Integer[][] dp = new Integer[A.length][B.length];
+        return helper(A, 0, B, 0, dp);
+    }
+    
+    private int helper(int[] A, int i, int[] B, int j, Integer[][] dp) {
+        if (i >= A.length || j >= B.length) {
+            return 0;
+        }
+        
+        if (dp[i][j] != null) {
+            return dp[i][j];
+        }
+        
+        if (A[i] == B[j]) {
+            dp[i][j] = 1 + helper(A, i + 1, B, j + 1, dp);
+        }
+        else {
+            dp[i][j] = Math.max(helper(A, i + 1, B, j, dp), helper(A, i, B, j + 1, dp));
+        }
+        
+        return dp[i][j];
+    }
+}

From 56cb3fd9f3e2aad164899c5e81d7c8cd97d78ca1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 16 Jul 2019 14:13:44 -0700
Subject: [PATCH 0011/2175] Added 2 solutions & modified 2 solutions

---
 Hard/Employee Free Time.java            | 32 +++++++++++
 Medium/Evaluate Division.java           | 73 +++++++++++++++++++++++++
 Medium/Exclusive Time of Functions.java | 46 ++++++----------
 Medium/Print Binary Tree.java           | 68 +++++++++++------------
 4 files changed, 154 insertions(+), 65 deletions(-)
 create mode 100644 Hard/Employee Free Time.java
 create mode 100644 Medium/Evaluate Division.java

diff --git a/Hard/Employee Free Time.java b/Hard/Employee Free Time.java
new file mode 100644
index 00000000..a5a33b13
--- /dev/null
+++ b/Hard/Employee Free Time.java	
@@ -0,0 +1,32 @@
+/**
+ * Definition for an interval.
+ * public class Interval {
+ *     int start;
+ *     int end;
+ *     Interval() { start = 0; end = 0; }
+ *     Interval(int s, int e) { start = s; end = e; }
+ * }
+ */
+/*
+*/
+class Solution {
+    public List<Interval> employeeFreeTime(List<List<Interval>> schedule) {
+        List<Interval> ans = new ArrayList<>();
+        PriorityQueue<Interval> pq = new PriorityQueue<>((a,b) -> a.start - b.start);
+        schedule.forEach(e -> pq.addAll(e));    
+    
+        Interval temp = pq.poll();
+        while (!pq.isEmpty()) {
+            if (temp.end < pq.peek().start) {
+                ans.add(new Interval(temp.end, pq.peek().start));
+                temp = pq.poll();
+            }
+            else {
+                temp = temp.end < pq.peek().end ? pq.peek() : temp;
+                pq.poll();
+            }
+        }
+        
+        return ans;
+    }   
+}
diff --git a/Medium/Evaluate Division.java b/Medium/Evaluate Division.java
new file mode 100644
index 00000000..76f57b3c
--- /dev/null
+++ b/Medium/Evaluate Division.java	
@@ -0,0 +1,73 @@
+class Solution {
+    public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
+        double[] ans = new double[queries.size()];
+
+        Map<String, Set<String>> map = new HashMap<>();
+        Map<String, Double> resMap = new HashMap<>();
+
+        for (int i = 0; i < equations.size(); i++) {
+            String operand1 = equations.get(i).get(0);
+            String operand2 = equations.get(i).get(1);
+
+            map.computeIfAbsent(operand1, k -> new HashSet<>()).add(operand2);
+            map.computeIfAbsent(operand2, k -> new HashSet<>()).add(operand1);
+
+            resMap.put(operand1 + "|" + operand2, values[i]);
+        }
+
+        for (int i = 0; i < queries.size(); i++) {
+            String operand1 = queries.get(i).get(0);
+            String operand2 = queries.get(i).get(1);
+
+            if (!map.containsKey(operand1) || !map.containsKey(operand2)) {
+                ans[i] = -1.0;
+            }
+            else if (operand1.equals(operand2)) {
+                ans[i] = 1.0;
+            }
+            else if (map.get(operand1).contains(operand2)) {
+                ans[i] = getSimpleDivisionVal(resMap, operand1, operand2);
+            }
+            else if (operand2.contains(operand1)) {
+                ans[i] = getSimpleDivisionVal(resMap, operand2, operand1);
+            }
+            else {
+                ans[i] = dfs(map, resMap, operand1, operand2, 1.0, new HashSet<>());
+            }
+        }
+
+        return ans;
+    }
+
+    private double dfs (Map<String, Set<String>> map, Map<String, Double> resMap, String operand1, String operand2,
+                        double base, Set<String> visited) {
+        if (visited.contains(operand1)) {
+            return -1.0;
+        }
+        if (map.get(operand1).contains(operand2)) {
+            return base * getSimpleDivisionVal(resMap, operand1, operand2);
+        }
+
+        visited.add(operand1);
+
+        double ans = -1.0;
+        Iterator<String> children = map.get(operand1).iterator();
+
+        while (children.hasNext()) {
+            String child = children.next();
+            if (!visited.contains(child)) {
+                ans = Math.max(ans, dfs(map, resMap, child, operand2, base * getSimpleDivisionVal(resMap, operand1, child), visited));
+            }
+        }
+
+        return ans;
+    }
+
+    private double getSimpleDivisionVal (Map<String, Double> resMap, String operand1, String operand2) {
+        if (resMap.containsKey(operand1 + "|" + operand2)) {
+            return resMap.get(operand1 + "|" + operand2);
+        }
+
+        return 1 / resMap.get(operand2 + "|" + operand1);
+    }
+}
diff --git a/Medium/Exclusive Time of Functions.java b/Medium/Exclusive Time of Functions.java
index ed23668b..0138ec69 100644
--- a/Medium/Exclusive Time of Functions.java	
+++ b/Medium/Exclusive Time of Functions.java	
@@ -1,42 +1,28 @@
 class Solution {
     public int[] exclusiveTime(int n, List<String> logs) {
-        int[] time = new int[n];
-
-        Stack<Task> tasks = new Stack<>();
+        int[] timer = new int[n];
+        Stack<Integer> stack = new Stack<>();
+        int lastTime = 0;;
 
         for (String log : logs) {
-            Task task = new Task(log);
+            String[] strs = log.split(":");
+            int id = Integer.parseInt(strs[0]);
+            String status = strs[1];
+            int time = Integer.parseInt(strs[2]);
 
-            if (task.status == Status.Start) {
-                tasks.push(task);
+            if (!stack.isEmpty()) {
+                timer[stack.peek()] += time - lastTime;
+            }
+            lastTime = time;
+            if (status.equals("start")) {
+                stack.push(id);
             }
             else {
-                Task top = tasks.pop();
-                time[top.num] += task.time - top.time + 1;
-
-                if (!tasks.isEmpty()) {
-                    time[tasks.peek().num] -= task.time - top.time + 1;
-                }
+                timer[stack.pop()]++;
+                lastTime++;
             }
         }
 
-        return time;
+        return timer;
     }
 }
-
-class Task {
-    public int num;
-    public int time;
-    public Status status;
-
-    public Task(String log) {
-        String[] strs = log.split(":");
-        this.num = Integer.parseInt(strs[0]);
-        this.time = Integer.parseInt(strs[2]);
-        this.status = strs[1].equals("start") ? Status.Start : Status.End;
-    }
-}
-
-enum Status {
-    Start, End;
-}
diff --git a/Medium/Print Binary Tree.java b/Medium/Print Binary Tree.java
index 3b211d02..ad19e97b 100644
--- a/Medium/Print Binary Tree.java	
+++ b/Medium/Print Binary Tree.java	
@@ -8,45 +8,43 @@
  * }
  */
 class Solution {
-
-    List<List<String>> ans = new ArrayList<>();
-        
     public List<List<String>> printTree(TreeNode root) {
-        int row = height(root);
-        int col = (int)(Math.pow(2, row) - 1);
-        
-        List<String> oneRow = new ArrayList<>();
-        
-        for (int i=0;i<col;i++) {
-            oneRow.add("");
-        }
-        
-        for (int i=0;i<row;i++) {
-            ans.add(new ArrayList<>(oneRow));
+        int height = getHeight(root);
+        int numOfNodes = (int) Math.pow(2, height) - 1;
+
+        List<List<String>> ans = new ArrayList<>();
+
+        for (int i = 0; i < height; i++) {
+            List<String> temp = new ArrayList<>();
+            for (int j = 0; j < numOfNodes; j++) {
+                temp.add("");
+            }
+
+            ans.add(temp);
         }
-        
-        helper(0, 0, col, root);
-        
+
+        updateList(ans, root, 0, 0, numOfNodes);
+
         return ans;
     }
-    
-    public void helper(int rowNum, int start, int end, TreeNode root) {
-    
-        if (root == null) return;
-        
-        int mid = (start + end)/2;
-        
-        List<String> temp = ans.get(rowNum);
-        temp.set(mid, String.valueOf(root.val));
-        
-        ans.set(rowNum, temp);
-        
-        helper(rowNum+1, start, mid-1, root.left);
-        helper(rowNum+1, mid+1, end, root.right);
+
+    private void updateList (List<List<String>> ans, TreeNode root, int idx, int start, int end) {
+        if (root == null) {
+            return;
+        }
+
+        int mid = (start + end) / 2;
+
+        ans.get(idx).set(mid, String.valueOf(root.val));
+        updateList(ans, root.left, idx + 1, start, mid - 1);
+        updateList(ans, root.right, idx + 1, mid + 1, end);
     }
-    
-    public int height(TreeNode root) {
-        if (root == null) return 0;
-        return 1 + Math.max(height(root.left), height(root.right));
+
+    private int getHeight (TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        return 1 + Math.max(getHeight(root.left), getHeight(root.right));
     }
 }

From 897a32d2ebb6ceaa35d263961d0635706a1f27da Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 17 Jul 2019 23:34:13 -0700
Subject: [PATCH 0012/2175] Modified 2 solutions

---
 Easy/Search Insert Position.java | 31 ++++++++---------
 Medium/Friend Circles.java       | 59 +++++++++++++++++---------------
 2 files changed, 46 insertions(+), 44 deletions(-)

diff --git a/Easy/Search Insert Position.java b/Easy/Search Insert Position.java
index bc1adfee..f36a96c8 100644
--- a/Easy/Search Insert Position.java	
+++ b/Easy/Search Insert Position.java	
@@ -1,26 +1,25 @@
 class Solution {
     public int searchInsert(int[] nums, int target) {
-        int low = 0;
-        int high = nums.length-1;
-        
-        if (nums[low] >= target) {
-            return 0;
-        }
-        
-        if (nums[high] < target) {
-            return high + 1;
-        }
+        return binarySearch(nums, target);
+    }
+    
+    private int binarySearch(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
         
-        while (low < high) {
-            int mid = (low + high)/2;
-            if (nums[mid] < target) {
-                low = mid+1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            }
+            else if (nums[mid] > target) {
+                right = mid - 1;
             }
             else {
-                high = mid;
+                left = mid + 1;
             }
         }
         
-        return low;
+        return left;
     }
 }
diff --git a/Medium/Friend Circles.java b/Medium/Friend Circles.java
index ad214b9d..4a1d3bbd 100644
--- a/Medium/Friend Circles.java	
+++ b/Medium/Friend Circles.java	
@@ -1,41 +1,44 @@
 class Solution {
     public int findCircleNum(int[][] M) {
-        Map<Integer, List<Integer>> map = new HashMap<>();
-        for (int i=0; i<M.length; i++) {
-            for (int j=0; j<M[i].length; j++) {
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        for (int i = 0; i < M.length; i++) {
+            for (int j = 0; j < M.length; j++) {
                 if (M[i][j] == 1) {
-                    map.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
-                    map.computeIfAbsent(j, k -> new ArrayList<>()).add(i);
+                    map.computeIfAbsent(i, k -> new HashSet<>()).add(j);
                 }
             }
         }
-
-        Set<Integer> set = new HashSet<>();
+        
+        return dfs(map, M.length);
+    }
+    
+    private int dfs(Map<Integer, Set<Integer>> map, int n) {
         int count = 0;
-        Queue<Integer> queue = new LinkedList<>();
-
-        for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
-            if (set.contains(entry.getKey())) {
-                continue;
+        Set<Integer> seen = new HashSet<>();
+        
+        for (int i = 0; i < n; i++) {
+            if (!seen.contains(i)) {
+                dfsHelper(i, seen, map);
+                count++;
             }
-
-            queue.add(entry.getKey());
-
-            while (!queue.isEmpty()) {
-                int popped = queue.remove();
-                set.add(popped);
-                List<Integer> list = map.get(popped);
-
-                for (Integer integer : list) {
-                    if (!set.contains(integer)) {
-                        queue.add(integer);
-                    }
+        }
+        
+        return count;
+    }
+    
+    private void dfsHelper(int idx, Set<Integer> seen, Map<Integer, Set<Integer>> map) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(idx);
+        
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            seen.add(removed);
+            
+            for (int friend : map.getOrDefault(removed, new HashSet<>())) {
+                if (!seen.contains(friend)) {
+                    queue.add(friend);
                 }
             }
-
-            count++;
         }
-
-        return count;
     }
 }

From 08d4dc58c6428c69c58c96f08cd50ad09e394954 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 18 Jul 2019 20:57:10 -0700
Subject: [PATCH 0013/2175] Modified 3 solutions

---
 Hard/Longest Increasing Path in a Matrix.java | 32 +++++-----
 Medium/Flatten Nested List Iterator.java      | 44 ++++++--------
 Medium/Sort Characters By Frequency.java      | 58 ++++++++-----------
 3 files changed, 55 insertions(+), 79 deletions(-)

diff --git a/Hard/Longest Increasing Path in a Matrix.java b/Hard/Longest Increasing Path in a Matrix.java
index 33c4d437..6ba938a2 100644
--- a/Hard/Longest Increasing Path in a Matrix.java	
+++ b/Hard/Longest Increasing Path in a Matrix.java	
@@ -1,42 +1,36 @@
 class Solution {
-    int[][] dp;
+    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
     public int longestIncreasingPath(int[][] matrix) {
         if (matrix.length == 0 || matrix[0].length == 0) {
             return 0;
         }
         
+        int[][] dp = new int[matrix.length][matrix[0].length];
         int max = 0;
-        dp = new int[matrix.length][matrix[0].length];
-        
         for (int i = 0; i < matrix.length; i++) {
             for (int j = 0; j < matrix[0].length; j++) {
-                max = Math.max(max, getIncreasingPathLength(matrix, i, j, Integer.MIN_VALUE));
+                max = Math.max(max, dfs(matrix, i, j, dp, Integer.MIN_VALUE));
             }
         }
         
         return max;
     }
     
-    private int getIncreasingPathLength(int[][] matrix, int row, int col, int prev) {
-        if (row < 0 || 
-            col < 0 || 
-            row >= matrix.length || 
-            col >= matrix[0].length || 
-            matrix[row][col] <= prev) {
+    private int dfs(int[][] matrix, int x, int y, int[][] dp, int prevVal) {
+        if (x < 0 || x >= matrix.length || y < 0 || y >= matrix[0].length || matrix[x][y] <= prevVal) {
             return 0;
         }
         
-        if (dp[row][col] != 0) {
-            return dp[row][col];
+        if (dp[x][y] != 0) {
+            return dp[x][y];
         }
         
-        int up = getIncreasingPathLength(matrix, row - 1, col, matrix[row][col]);
-        int down = getIncreasingPathLength(matrix, row + 1, col, matrix[row][col]);
-        int right = getIncreasingPathLength(matrix, row, col + 1, matrix[row][col]);
-        int left = getIncreasingPathLength(matrix, row, col - 1, matrix[row][col]);
-        
-        dp[row][col] = 1 + Math.max(Math.max(up, down), Math.max(right, left));
+        int temp = 0;
+        for (int[] dir : dirs) {
+            temp = Math.max(temp, dfs(matrix, x + dir[0], y + dir[1], dp, matrix[x][y]));
+        }
         
-        return dp[row][col];
+        dp[x][y] = temp + 1;
+        return dp[x][y];
     }
 }
diff --git a/Medium/Flatten Nested List Iterator.java b/Medium/Flatten Nested List Iterator.java
index d0ac3dbc..a4253545 100644
--- a/Medium/Flatten Nested List Iterator.java	
+++ b/Medium/Flatten Nested List Iterator.java	
@@ -16,41 +16,35 @@
  * }
  */
 public class NestedIterator implements Iterator<Integer> {
-    List<Integer> list;
-    int index;
-    int size;
-    public NestedIterator(List<NestedInteger> nestedList) {
-        list = new ArrayList<>();
-        index = 0;
-        for (NestedInteger n : nestedList) {
-            dfsHelper(n);
-        }
-        
-        size = list.size();
-    }
     
-    private void dfsHelper(NestedInteger n) {
-        if (n.isInteger()) {
-            list.add(n.getInteger());
-        }
-        else {
-            for (NestedInteger ni : n.getList()) {
-                dfsHelper(ni);
-            }
+    Stack<NestedInteger> stack;
+    public NestedIterator(List<NestedInteger> nestedList) {
+        stack = new Stack<>();
+        for (int i = nestedList.size() - 1; i >= 0; i--) {
+            stack.push(nestedList.get(i));
         }
     }
 
     @Override
     public Integer next() {
-        if (index < size) {
-            return list.get(index++);
-        }
-        return -1;
+        return stack.pop().getInteger();
     }
 
     @Override
     public boolean hasNext() {
-        return !(index == size);        
+        while (!stack.isEmpty()) {
+            NestedInteger curr = stack.peek();
+            if (curr.isInteger()) {
+                return true;
+            }
+            
+            NestedInteger temp = stack.pop();
+            for (int i = temp.getList().size() - 1; i >= 0; i--) {
+                stack.push(temp.getList().get(i));
+            }
+        }
+        
+        return false;
     }
 }
 
diff --git a/Medium/Sort Characters By Frequency.java b/Medium/Sort Characters By Frequency.java
index e504b12b..134f437b 100644
--- a/Medium/Sort Characters By Frequency.java	
+++ b/Medium/Sort Characters By Frequency.java	
@@ -1,47 +1,35 @@
 class Solution {
-    
     public String frequencySort(String s) {
-        Map<Character, Integer> map = new HashMap<>();
-
-        for (int i=0;i<s.length();i++) {
-            if (map.containsKey(s.charAt(i))) {
-                map.put(s.charAt(i), map.get(s.charAt(i))+1);
-            }
-            else {
-                map.put(s.charAt(i), 1);
-            }
+        List<Character> chars = new ArrayList<>();
+        for (char c : s.toCharArray()) {
+            chars.add(c);
         }
 
-        Map<Character, Integer> sortedMap = sortByValue(map);
-
-
-        StringBuilder sb = new StringBuilder("");
-
-        for (Map.Entry<Character,Integer> entry : sortedMap.entrySet()) {
-            String t = String.join("", Collections.nCopies(entry.getValue(), String.valueOf(entry.getKey())));
-            sb.append(t);
+        Map<Character, Integer> map = new HashMap<>();
+        int val = 0;
+        for (char c : chars) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+            val = Math.max(val, map.get(c));
         }
 
-        return sb.toString();
-    }
-
-    private Map<Character, Integer> sortByValue(Map<Character, Integer> unsortMap) {
-
-        List<Map.Entry<Character, Integer>> list =
-                new LinkedList<Map.Entry<Character, Integer>>(unsortMap.entrySet());
+        Map<Integer, List<Character>> revMap = new HashMap<>();
+        for (Character key : map.keySet()) {
+            revMap.computeIfAbsent(map.get(key), k -> new ArrayList<>()).add(key);
+        }
 
-        Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() {
-            public int compare(Map.Entry<Character, Integer> o1,
-                               Map.Entry<Character, Integer> o2) {
-                return (o2.getValue()).compareTo(o1.getValue());
+        StringBuilder sb = new StringBuilder();
+        for (int i = val; i >= 0; i--) {
+            if (revMap.containsKey(i)) {
+                List<Character> characters = revMap.get(i);
+                for (Character character : characters) {
+                    int count = i;
+                    while (count-- > 0) {
+                        sb.append(character);
+                    }
+                }
             }
-        });
-
-        Map<Character, Integer> sortedMap = new LinkedHashMap<Character, Integer>();
-        for (Map.Entry<Character, Integer> entry : list) {
-            sortedMap.put(entry.getKey(), entry.getValue());
         }
 
-        return sortedMap;
+        return sb.toString();
     }
 }

From 33ec853a9a22302aa5bb2697ce1270fe803a3ae8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 19 Jul 2019 20:09:06 -0700
Subject: [PATCH 0014/2175] Added 1 solution

---
 Hard/Robot Room Cleaner.java | 63 ++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 Hard/Robot Room Cleaner.java

diff --git a/Hard/Robot Room Cleaner.java b/Hard/Robot Room Cleaner.java
new file mode 100644
index 00000000..aa4cfae6
--- /dev/null
+++ b/Hard/Robot Room Cleaner.java	
@@ -0,0 +1,63 @@
+/**
+ * // This is the robot's control interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface Robot {
+ *     // Returns true if the cell in front is open and robot moves into the cell.
+ *     // Returns false if the cell in front is blocked and robot stays in the current cell.
+ *     public boolean move();
+ *
+ *     // Robot will stay in the same cell after calling turnLeft/turnRight.
+ *     // Each turn will be 90 degrees.
+ *     public void turnLeft();
+ *     public void turnRight();
+ *
+ *     // Clean the current cell.
+ *     public void clean();
+ * }
+ */
+class Solution {
+    public void cleanRoom(Robot robot) {
+        Set<String> visited = new HashSet<>();
+        backtrack(robot, visited, 0, 0, 0);
+    }
+    
+    private void backtrack(Robot robot, Set<String> visited, int x, int y, int dir) {
+        String key = x + "|" + y;
+        if (visited.contains(key)) {
+            return;
+        }
+        
+        visited.add(key);
+        robot.clean();
+        
+        for (int k = 0; k < 4; k++) {
+            int i = x;
+            int j = y;
+            if (robot.move()) {
+                if (dir == 0) {
+                    i = x - 1;
+                }
+                else if (dir == 1) {
+                    j = y + 1;
+                }
+                else if (dir == 2) {
+                    i = x + 1;
+                }
+                else {
+                    j = y - 1;
+                }
+                
+                backtrack(robot, visited, i, j, dir);
+                robot.turnLeft();
+                robot.turnLeft();
+                robot.move();
+                robot.turnRight();
+                robot.turnRight();
+            }
+            
+            robot.turnRight();
+            dir += 1;
+            dir %= 4;
+        }
+    }
+}

From c851bad18955cc36ab06f370df0ab7947929f9a3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 20 Jul 2019 19:49:21 -0700
Subject: [PATCH 0015/2175] Added 2 solutions & modified 2 solutions

---
 Hard/N-Queens.java          | 50 +++++++++++++++++++++++++++++++++++++
 Hard/Word Break II.java     | 29 +++++++++++++++++++++
 Medium/Permutations II.java | 48 ++++++++++++++++-------------------
 Medium/Permutations.java    | 46 ++++++++++++++++------------------
 4 files changed, 122 insertions(+), 51 deletions(-)
 create mode 100644 Hard/N-Queens.java
 create mode 100644 Hard/Word Break II.java

diff --git a/Hard/N-Queens.java b/Hard/N-Queens.java
new file mode 100644
index 00000000..2e382180
--- /dev/null
+++ b/Hard/N-Queens.java
@@ -0,0 +1,50 @@
+class Solution {
+  public List<List<String>> solveNQueens(int n) {
+    List<List<String>> ans = new ArrayList <>();
+    helper(n, 0, new ArrayList<>(), ans);
+    return ans;
+  }
+
+  private void helper(int n, int row, List<Integer> selections, List<List<String>> ans) {
+    if (row == n) {
+      ans.add(convertToString(selections, n));
+    }
+    else {
+      for (int i = 0; i < n; i++) {
+        selections.add(i);
+        if (isValid(selections)) {
+          helper(n, row + 1, selections, ans);
+        }
+        selections.remove(selections.size() - 1);
+      }
+    }
+  }
+
+  private List <String> convertToString(List <Integer> selections, int n) {
+    List<String> ret = new ArrayList<>();
+    for (int i = 0; i < selections.size(); i++) {
+      StringBuilder sb = new StringBuilder();
+      for (int j = 0; j < n; j++) {
+        if (j == selections.get(i)) {
+          sb.append("Q");
+        }
+        else {
+          sb.append(".");
+        }
+      }
+      ret.add(sb.toString());
+    }
+    return ret;
+  }
+
+  private boolean isValid(List <Integer> selections) {
+    int row = selections.size() - 1;
+    for (int i = 0; i < row; i++) {
+      int diff = Math.abs(selections.get(i) - selections.get(row));
+      if (diff == 0 || diff == row - i) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
diff --git a/Hard/Word Break II.java b/Hard/Word Break II.java
new file mode 100644
index 00000000..86ff0a9c
--- /dev/null
+++ b/Hard/Word Break II.java	
@@ -0,0 +1,29 @@
+class Solution {
+  Map<Integer, List<String>> map = new HashMap<>();
+  public List<String> wordBreak(String s, List <String> wordDict) {
+    Set<String> set = new HashSet<>(wordDict);
+    return helper(s, set, 0);
+  }
+
+  private List<String> helper(String s, Set<String> set, int start) {
+    if (map.containsKey(start)) {
+      return map.get(start);
+    }
+
+    List<String> ans = new ArrayList <>();
+    if (start == s.length()) {
+      ans.add("");
+    }
+    for (int i = start + 1; i <= s.length(); i++) {
+      if (set.contains(s.substring(start, i))) {
+        List<String> list = helper(s, set, i);
+        for (String word : list) {
+          ans.add(s.substring(start, i) + (word.equals("") ? "" : " ") + word);
+        }
+      }
+    }
+
+    map.put(start, ans);
+    return ans;
+  }
+}
diff --git a/Medium/Permutations II.java b/Medium/Permutations II.java
index 74ca2f6f..1e74de1d 100644
--- a/Medium/Permutations II.java	
+++ b/Medium/Permutations II.java	
@@ -1,32 +1,28 @@
 class Solution {
-    public static List<List<Integer>> permuteUnique(int[] nums) {
-        List<List<Integer>> ans = new ArrayList<>();
-        Arrays.sort(nums);
-        permuteHelper(nums, new ArrayList<>(), ans, new boolean[nums.length]);
-        return new ArrayList<>(ans);
+  public List<List<Integer>> permuteUnique(int[] nums) {
+    Set<List<Integer>> ans = new HashSet <>();
+    Map <Integer, Integer> map = new HashMap <>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
     }
+    permuteHelper(nums, nums.length, ans, map, new ArrayList<>());
+    return new ArrayList <>(ans);
+  }
 
-    private static void permuteHelper(int[] nums, List<Integer> list, List<List<Integer>> ans, boolean[] used) {
-        if (list.size() == nums.length) {
-            ans.add(new ArrayList<>(list));
-        }
-        else {
-            for (int i=0; i<nums.length; i++) {
-                // Choose
-                if (used[i] || (i > 0 && nums[i] == nums[i-1] && !used[i-1])) {
-                    continue;
-                }
-
-                used[i] = true;
-                list.add(nums[i]);
-
-                // Explore
-                permuteHelper(nums, list, ans, used);
+  private void permuteHelper(int[] nums, int length, Set<List<Integer>> ans, Map<Integer, Integer> used, ArrayList<Integer> curr) {
+    if (curr.size() == length) {
+      ans.add(new ArrayList <>(curr));
+      return;
+    }
 
-                // Un-choose
-                used[i] = false;
-                list.remove(list.size()-1);
-            }
-        }
+    for (int i = 0; i < length; i++) {
+      if (used.get(nums[i]) != 0) {
+        used.put(nums[i], used.get(nums[i]) - 1);
+        curr.add(nums[i]);
+        permuteHelper(nums, length, ans, used, curr);
+        used.put(nums[i], used.get(nums[i]) + 1);
+        curr.remove(curr.size() - 1);
+      }
     }
+  }
 }
diff --git a/Medium/Permutations.java b/Medium/Permutations.java
index 0d40a3f9..f09beb5e 100644
--- a/Medium/Permutations.java
+++ b/Medium/Permutations.java
@@ -1,30 +1,26 @@
 class Solution {
-    public List<List<Integer>> ans = new ArrayList<>();
-    
-    public List<List<Integer>> permute(int[] nums) {
-        List<Integer> list = new ArrayList<>();
-        permuteHelper(nums, list, 0);
-        return ans;
-    }
-
-    private void permuteHelper(int[] nums, List<Integer> list, int idx) {
-        if (list.size() == nums.length) {
-            ans.add(new ArrayList<>(list));
-        }
-        else {
-            for (int i=0; i<nums.length; i++) {
-                // Choose
-                if (list.contains(nums[i])) {
-                    continue;
-                }
-                list.add(nums[i]);
+  public List<List<Integer>> permute(int[] nums) {
+    List<List<Integer>> ans = new ArrayList <>();
+    Set<Integer> used = new HashSet <>();
+    permuteHelper(nums, nums.length, ans, used, new ArrayList<>());
+    return ans;
+  }
 
-                // Explore
-                permuteHelper(nums, list, i+1);
+  private void permuteHelper(int[] nums, int length, List<List<Integer>> ans,
+                                    Set<Integer> used, ArrayList<Integer> curr) {
+    if (curr.size() == length) {
+      ans.add(new ArrayList <>(curr));
+      return;
+    }
 
-                // Un-choose
-                list.remove(list.size()-1);
-            }
-        }
+    for (int i = 0; i < length; i++) {
+      if (!used.contains(nums[i])) {
+        used.add(nums[i]);
+        curr.add(nums[i]);
+        permuteHelper(nums, length, ans, used, curr);
+        used.remove(nums[i]);
+        curr.remove(curr.size() - 1);
+      }
     }
+  }
 }

From 16bff8ab06e755dc7c2ef222025922cd200deb70 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 22 Jul 2019 10:22:17 -0700
Subject: [PATCH 0016/2175] Added 3 solutions

---
 Easy/Number of Equivalent Domino Pairs.java | 16 +++++++
 Easy/Rotting Oranges.java                   | 48 +++++++++++++++++++++
 Medium/Walls and Gates.java                 | 40 +++++++++++++++++
 3 files changed, 104 insertions(+)
 create mode 100644 Easy/Number of Equivalent Domino Pairs.java
 create mode 100644 Easy/Rotting Oranges.java
 create mode 100644 Medium/Walls and Gates.java

diff --git a/Easy/Number of Equivalent Domino Pairs.java b/Easy/Number of Equivalent Domino Pairs.java
new file mode 100644
index 00000000..653043b5
--- /dev/null
+++ b/Easy/Number of Equivalent Domino Pairs.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int numEquivDominoPairs(int[][] dominoes) {
+        Map<String, Integer> map = new HashMap <>();
+        for (int i = 0; i < dominoes.length; i++) {
+            String key = Math.min(dominoes[i][0], dominoes[i][1]) + "|" + Math.max(dominoes[i][0], dominoes[i][1]);
+            map.put(key, map.getOrDefault(key, 0) + 1);
+        }
+        
+        int count = 0;
+        for (int value : map.values()) {
+            count += (value * (value - 1)) / 2;
+        }
+        
+        return count;
+    }
+}
diff --git a/Easy/Rotting Oranges.java b/Easy/Rotting Oranges.java
new file mode 100644
index 00000000..fde319fb
--- /dev/null
+++ b/Easy/Rotting Oranges.java	
@@ -0,0 +1,48 @@
+class Solution {
+    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    public int orangesRotting(int[][] grid) {
+        Queue<Integer> queue = new LinkedList<>();
+        Map<Integer, Integer> map = new HashMap<>();
+        int numRows = grid.length;
+        int numCols = grid[0].length;
+
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                if (grid[i][j] == 2) {
+                    int key = numCols * i + j;
+                    queue.add(key);
+                    map.put(key, 0);
+                }
+            }
+        }
+
+        int ans = 0;
+        while (!queue.isEmpty()) {
+            int key = queue.remove();
+            int x = key / numCols;
+            int y = key % numCols;
+            for (int[] dir : dirs) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                if (newX < 0 || newX >= numRows || newY < 0 || newY >= numCols || grid[newX][newY] != 1) {
+                    continue;
+                }
+                grid[newX][newY] = 2;
+                int newKey = newX * numCols + newY;
+                queue.add(newKey);
+                map.put(newKey, map.get(key) + 1);
+                ans = map.get(newKey);
+            }
+        }
+
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                if (grid[i][j] == 1) {
+                    return -1;
+                }
+            }
+        }
+
+        return ans;
+    }
+}
diff --git a/Medium/Walls and Gates.java b/Medium/Walls and Gates.java
new file mode 100644
index 00000000..e030ae7a
--- /dev/null
+++ b/Medium/Walls and Gates.java	
@@ -0,0 +1,40 @@
+class Solution {
+    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    public void wallsAndGates(int[][] rooms) {
+        if (rooms.length == 0 || rooms[0].length == 0) {
+            return;
+        }
+        
+        Queue<Integer> queue = new LinkedList<>();
+        int numRows = rooms.length;
+        int numCols = rooms[0].length;
+        
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                if (rooms[i][j] == 0) {
+                    int key = i * numCols + j;
+                    queue.add(key);
+                }
+            }
+        }
+        
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            int x = removed / numCols;
+            int y = removed % numCols;
+            
+            for (int[] dir : dirs) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                
+                if (newX < 0 || newX >= numRows || newY < 0 || newY >= numCols || rooms[newX][newY] != 2147483647) {
+                    continue;    
+                }
+                
+                rooms[newX][newY] = rooms[x][y] + 1;
+                int newKey = newX * numCols + newY;
+                queue.add(newKey);
+            }
+        }
+    }
+}

From c13ae654e34b6703b3d682a3a3cfe0b2f8373678 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 27 Jul 2019 09:28:38 -0700
Subject: [PATCH 0017/2175] Added 2 solutions & modified 1 solution

---
 Easy/Armstrong Number.java      | 27 +++++++++++++++++++++++++++
 Easy/Largest Unique Number.java | 17 +++++++++++++++++
 Medium/Teemo Attacking.java     | 20 +++++++++++---------
 3 files changed, 55 insertions(+), 9 deletions(-)
 create mode 100644 Easy/Armstrong Number.java
 create mode 100644 Easy/Largest Unique Number.java

diff --git a/Easy/Armstrong Number.java b/Easy/Armstrong Number.java
new file mode 100644
index 00000000..fa13ed94
--- /dev/null
+++ b/Easy/Armstrong Number.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public boolean isArmstrong(int N) {
+        int n = getLength(N);
+        return getNthPowerSum(N, n) == N;
+    }
+
+    private int getNthPowerSum(int n, int p) {
+        int sum = 0;
+        while (n > 0) {
+            int temp = n % 10;
+            n /= 10;
+            sum += (int) Math.pow(temp, p);
+        }
+
+        return sum;
+    }
+
+    private int getLength(int n) {
+        int count = 0;
+        while (n > 0) {
+            n /= 10;
+            count++;
+        }
+
+        return count;
+    }
+}
diff --git a/Easy/Largest Unique Number.java b/Easy/Largest Unique Number.java
new file mode 100644
index 00000000..00191b7b
--- /dev/null
+++ b/Easy/Largest Unique Number.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int largestUniqueNumber(int[] A) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : A) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+
+        int maxVal = Integer.MIN_VALUE;
+        for (Integer key : map.keySet()) {
+            if (map.get(key) == 1) {
+                maxVal = Math.max(maxVal, key);
+            }
+        }
+
+        return maxVal == Integer.MIN_VALUE ? -1 : maxVal;
+    }
+}
diff --git a/Medium/Teemo Attacking.java b/Medium/Teemo Attacking.java
index 14f6e450..3224640e 100644
--- a/Medium/Teemo Attacking.java	
+++ b/Medium/Teemo Attacking.java	
@@ -1,14 +1,16 @@
 class Solution {
     public int findPoisonedDuration(int[] timeSeries, int duration) {
+        if (duration == 0 || timeSeries.length == 0) {
+            return 0;
+        }
+
+        int totalTime = 0;
+        int beginTime = timeSeries[0];
+        for (int time : timeSeries) {
+            totalTime += (time < beginTime + duration ? time - beginTime : duration);
+            beginTime = time;
+        }
         
-        if (timeSeries.length == 0 || duration == 0) return 0;
-        
-            int begin = timeSeries[0], total = 0;
-            for (int t : timeSeries) {
-                total = total + (t < begin + duration ? t - begin : duration);
-                begin = t;
-            }   
-        
-        return total + duration;
+        return totalTime + duration;
     }
 }

From 0089007032e197f4deead773936edbf93cf2bf36 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 30 Jul 2019 08:19:36 -0700
Subject: [PATCH 0018/2175] Added 2 solutions & modified 1 solution

---
 Easy/N-th Tribonacci Number.java              | 24 ++++++
 Easy/Valid Parantheses.java                   | 28 ++++---
 ...d Search Word - Data structure design.java | 78 +++++++++++++++++++
 3 files changed, 118 insertions(+), 12 deletions(-)
 create mode 100644 Easy/N-th Tribonacci Number.java
 create mode 100644 Medium/Add and Search Word - Data structure design.java

diff --git a/Easy/N-th Tribonacci Number.java b/Easy/N-th Tribonacci Number.java
new file mode 100644
index 00000000..ebb955b4
--- /dev/null
+++ b/Easy/N-th Tribonacci Number.java	
@@ -0,0 +1,24 @@
+class Solution {
+    Integer[] memo;
+    public int tribonacci(int n) {
+        memo = new Integer[n + 1];
+        return helper(n);
+    }
+
+    private int helper(int n) {
+        if (n == 0) {
+            return 0;
+        }
+
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+
+        if (memo[n] != null) {
+            return memo[n];
+        }
+
+        memo[n] = helper(n - 3) + helper(n - 2) + helper(n - 1);
+        return memo[n];
+    }
+}
diff --git a/Easy/Valid Parantheses.java b/Easy/Valid Parantheses.java
index c33858a1..6991cd9f 100644
--- a/Easy/Valid Parantheses.java	
+++ b/Easy/Valid Parantheses.java	
@@ -1,24 +1,28 @@
 class Solution {
+    public Map<Character, Character> map = new HashMap<Character, Character>(){{
+        put('{', '}');
+        put('[', ']');
+        put('(', ')');
+    }};
+
     public boolean isValid(String s) {
         Stack<Character> stack = new Stack<>();
-        String open = "{([";
-        String close = "})]";
-        for (int i=0;i<s.length();i++) {
-            if (open.indexOf(s.charAt(i)) != -1) {
-                stack.push(s.charAt(i));
+        for (char c : s.toCharArray()) {
+            if (map.containsKey(c)) {
+                stack.push(c);
             }
             else {
-                if (!stack.empty()) {
-                    char c = stack.pop();
-                    if (open.indexOf(c) != close.indexOf(s.charAt(i))) {
-                        return false;
-                    }
+                if (stack.isEmpty()) {
+                    return false;
                 }
-                else {
+
+                char removed = stack.pop();
+                if (map.get(removed) != c) {
                     return false;
                 }
             }
         }
-        return stack.empty();
+
+        return stack.isEmpty();
     }
 }
diff --git a/Medium/Add and Search Word - Data structure design.java b/Medium/Add and Search Word - Data structure design.java
new file mode 100644
index 00000000..de90b231
--- /dev/null
+++ b/Medium/Add and Search Word - Data structure design.java	
@@ -0,0 +1,78 @@
+class WordDictionary {
+
+    /** Initialize your data structure here. */
+    TrieNode root;
+    public WordDictionary() {
+        root = new TrieNode();
+    }
+    
+    /** Adds a word into the data structure. */
+    public void addWord(String word) {
+        addToTrie(word);
+    }
+    
+    private void addToTrie(String word) {
+        TrieNode curr = root;
+        for (int i = 0; i < word.length(); i++) {
+            char c = word.charAt(i);
+            if (curr.children[c - 'a'] == null) {
+                curr.children[c - 'a'] = new TrieNode();
+            }
+            
+            curr = curr.children[c - 'a'];
+            
+            if (i == word.length() - 1) {
+                curr.isWord = true;
+            }
+        }
+    }
+    
+    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
+    public boolean search(String word) {
+        TrieNode curr = root;
+        boolean[] ans = {false};
+        helper(word, 0, curr, ans);
+        return ans[0];
+    }
+    
+    private void helper(String word, int idx, TrieNode curr, boolean[] ans) {
+        if (curr == null) {
+            return;
+        }
+        
+        if (idx == word.length()) {
+            if (curr.isWord) {
+                ans[0] = true;
+            }
+            return;
+        }
+        
+        if (word.charAt(idx) != '.') {
+            helper(word, idx + 1, curr.children[word.charAt(idx) - 'a'], ans);
+        }
+        else {
+            for (int i = 0; i < 26; i++) {
+                if (curr.children[i] != null) {
+                    helper(word, idx + 1, curr.children[i], ans);
+                }
+            }
+        }
+    }
+}
+
+class TrieNode {
+    TrieNode[] children;
+    boolean isWord;
+        
+    public TrieNode() {
+        children = new TrieNode[26];
+        isWord = false;
+    }
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary obj = new WordDictionary();
+ * obj.addWord(word);
+ * boolean param_2 = obj.search(word);
+ */

From 3cf75a166b9236575d984555a8f2e3d32fe6f154 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 31 Jul 2019 07:46:09 -0700
Subject: [PATCH 0019/2175] Added 2 solutions

---
 Hard/Parallel Courses.java     | 46 ++++++++++++++++++++++++++++++++++
 Medium/Is Graph Bipartite.java | 29 +++++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 Hard/Parallel Courses.java
 create mode 100644 Medium/Is Graph Bipartite.java

diff --git a/Hard/Parallel Courses.java b/Hard/Parallel Courses.java
new file mode 100644
index 00000000..f2470294
--- /dev/null
+++ b/Hard/Parallel Courses.java	
@@ -0,0 +1,46 @@
+class Solution {
+    public int minimumSemesters(int N, int[][] relations) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        // A prerequisite counter for each course
+        int[] prereqs = new int[N + 1];
+        
+        for (int[] relation : relations) {
+            map.computeIfAbsent(relation[0], k-> new ArrayList<>()).add(relation[1]);
+            prereqs[relation[1]]++;
+        }
+        
+        Queue<Integer> queue = new LinkedList<>();
+        
+        // Add all the courses which have no prerequisite
+        // So that we can take those courses in first semester
+        for (int i = 1; i <= N; i++) {
+            if (prereqs[i] == 0) {
+                queue.add(i);
+            }
+        }
+        
+        int semester = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int course = queue.poll();
+                // Decrement N as we have taken a course that is removed from the queue
+                N--;
+                for (int pre : map.getOrDefault(course, new ArrayList<>())) {
+                    /*
+                    If a course which depends upon the removed course had only the removed course as prereq then we can
+                    add it to the queue
+                    */
+                    if (--prereqs[pre] == 0) {
+                        queue.add(pre);
+                    }
+                }
+            }
+            
+            // Semester over. New semester starts
+            semester++;
+        }
+
+        return N == 0 ? semester : -1;
+    }
+}
diff --git a/Medium/Is Graph Bipartite.java b/Medium/Is Graph Bipartite.java
new file mode 100644
index 00000000..19c708ea
--- /dev/null
+++ b/Medium/Is Graph Bipartite.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public boolean isBipartite(int[][] graph) {
+        int[] colors = new int[graph.length];
+        Arrays.fill(colors, -1);
+        Stack<Integer> stack = new Stack<>();
+        
+        for (int i = 0; i < graph.length; i++) {
+            if (colors[i] == -1) {
+                stack.push(i);
+                colors[i] = 0;
+                
+                while (!stack.isEmpty()) {
+                    Integer removed = stack.pop();
+                    for (Integer connect : graph[removed]) {
+                        if (colors[connect] == -1) {
+                            stack.push(connect);
+                            colors[connect] = colors[removed] == 1 ? 0 : 1;
+                        }
+                        else if (colors[connect] == colors[removed]) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        
+        return true;
+    }
+}

From 786396547055cb4ee4b61dcc0c0a70c68b8c0ec5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 2 Aug 2019 17:38:52 -0700
Subject: [PATCH 0020/2175] Added 1 solution & modified 1 solution

---
 Easy/Excel Sheet Column Number.java | 11 ++++++++
 Easy/excel_sheet_column_number.java | 15 -----------
 Medium/Accounts Merge.java          | 42 +++++++++++++++++++++++++++++
 3 files changed, 53 insertions(+), 15 deletions(-)
 create mode 100644 Easy/Excel Sheet Column Number.java
 delete mode 100644 Easy/excel_sheet_column_number.java
 create mode 100644 Medium/Accounts Merge.java

diff --git a/Easy/Excel Sheet Column Number.java b/Easy/Excel Sheet Column Number.java
new file mode 100644
index 00000000..a75e2708
--- /dev/null
+++ b/Easy/Excel Sheet Column Number.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int titleToNumber(String s) {
+        int pow = 0;
+        int count = 0;
+        for (int i = s.length() - 1; i >= 0; i--) {
+            count += ((int) Math.pow(26, pow++)) * (s.charAt(i) - 'A' + 1);
+        }
+        
+        return count;
+    }
+}
diff --git a/Easy/excel_sheet_column_number.java b/Easy/excel_sheet_column_number.java
deleted file mode 100644
index eb0fc2d4..00000000
--- a/Easy/excel_sheet_column_number.java
+++ /dev/null
@@ -1,15 +0,0 @@
-public class Solution {
-    public int titleToNumber(String s) {
-        int val = 0;
-        int n = s.length();
-        int j = 1;
-        for (int i=0;i<n-1;i++) {
-            val += Math.pow(26,n-i-1)*((int)(s.charAt(i)) - 64);
-            j++;
-        }
-        char c = s.charAt(s.length()-1);
-        val += (int)c - 64;
-        
-        return val;
-    }
-}
\ No newline at end of file
diff --git a/Medium/Accounts Merge.java b/Medium/Accounts Merge.java
new file mode 100644
index 00000000..0170b23c
--- /dev/null
+++ b/Medium/Accounts Merge.java	
@@ -0,0 +1,42 @@
+class Solution {
+    public List<List<String>> accountsMerge(List<List<String>> accounts) {
+        Map<String, String> emailToName = new HashMap<>();
+        Map<String, List<String>> graph = new HashMap<>();
+        
+        for (List<String> account : accounts) {
+            String name = account.get(0);
+            
+            for (int i = 1; i < account.size(); i++) {
+                graph.computeIfAbsent(account.get(i), k -> new ArrayList<>()).add(account.get(1));
+                graph.computeIfAbsent(account.get(1), k -> new ArrayList<>()).add(account.get(i));
+                emailToName.put(account.get(i), name);
+            }
+        }
+        
+        Set<String> visited = new HashSet<>();
+        List<List<String>> mergedAccounts = new ArrayList<>();
+        for (String email : graph.keySet()) {
+            if (!visited.contains(email)) {
+                visited.add(email);
+                Stack<String> stack = new Stack<>();
+                stack.push(email);
+                List<String> singleAccount = new ArrayList<>();
+                while (!stack.isEmpty()) {
+                    String removed = stack.pop();
+                    singleAccount.add(removed);
+                    for (String connected : graph.get(removed)) {
+                        if (!visited.contains(connected)) {
+                            visited.add(connected);
+                            stack.push(connected);
+                        }
+                    }
+                }
+                Collections.sort(singleAccount);
+                singleAccount.add(0, emailToName.get(email));
+                mergedAccounts.add(singleAccount);
+            }
+        }
+        
+        return mergedAccounts;
+    }
+}

From 6ec05b8d3307b793ffd62f223b7290c791c68a9a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 3 Aug 2019 22:00:00 -0700
Subject: [PATCH 0021/2175] Added 1 solution

---
 Medium/Rectangle Area.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Rectangle Area.java

diff --git a/Medium/Rectangle Area.java b/Medium/Rectangle Area.java
new file mode 100644
index 00000000..463dd331
--- /dev/null
+++ b/Medium/Rectangle Area.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
+        int area = ((D - B) * (C - A)) + ((H - F) * (G- E));
+        area -= overlap(A, C, E, G) * overlap(B, D, F, H);
+        return area;
+    }
+    
+    private int overlap(int x1, int x2, int x3, int x4) {
+        if (x2 <= x3) {
+            return 0;
+        }
+        
+        if (x1 >= x4) {
+            return 0;
+        }
+        
+        return Math.min(x2, x4) - Math.max(x1, x3);
+    }
+}

From 319cab923a73d8572da659802a598d1505793860 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Aug 2019 09:17:03 -0700
Subject: [PATCH 0022/2175] Added 3 solutions

---
 ...ecrease Elements To Make Array Zigzag.java | 28 ++++++++++++
 Medium/Snapshot Array.java                    | 45 +++++++++++++++++++
 Medium/Total Hamming Distance.java            | 15 +++++++
 3 files changed, 88 insertions(+)
 create mode 100644 Medium/Decrease Elements To Make Array Zigzag.java
 create mode 100644 Medium/Snapshot Array.java
 create mode 100644 Medium/Total Hamming Distance.java

diff --git a/Medium/Decrease Elements To Make Array Zigzag.java b/Medium/Decrease Elements To Make Array Zigzag.java
new file mode 100644
index 00000000..4dcfd567
--- /dev/null
+++ b/Medium/Decrease Elements To Make Array Zigzag.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public int movesToMakeZigzag(int[] nums) {
+        return Math.min(calculateMove(nums, true), calculateMove(nums, false));
+    }
+    
+    private int calculateMove(int[] nums, boolean isEven) {
+        int count = 0;
+        
+        for (int i = (isEven ? 0 : 1); i < nums.length; i += 2) {
+            int curr = 0;
+            if (i + 1 < nums.length) {
+                if (nums[i] >= nums[i + 1]) {
+                    curr = nums[i] - nums[i + 1] + 1;
+                }
+            }
+            
+            if (i - 1 >= 0) {
+                if (nums[i] >= nums[i - 1]) {
+                    curr = Math.max(curr, nums[i] - nums[i - 1] + 1);
+                }
+            }
+            
+            count += curr;
+        }
+        
+        return count;
+    }
+}
diff --git a/Medium/Snapshot Array.java b/Medium/Snapshot Array.java
new file mode 100644
index 00000000..9459d694
--- /dev/null
+++ b/Medium/Snapshot Array.java	
@@ -0,0 +1,45 @@
+class SnapshotArray {
+
+    int[] arr;
+    Map<Integer, Map<Integer, Integer>> map;
+    int count;
+    Map<Integer, Integer> temp;
+    public SnapshotArray(int length) {
+        arr = new int[length];
+        map = new HashMap<>();
+        count = 0;
+        temp = new HashMap<>();
+    }
+
+    public void set(int index, int val) {
+        arr[index] = val;
+        temp.put(index, val);
+    }
+
+    public int snap() {
+        map.put(count, new HashMap<>(temp));
+        int snapCount = count++;
+        temp = new HashMap<>();
+        return snapCount;
+    }
+
+    public int get(int index, int snap_id) {
+        while (snap_id >= 0) {
+            if (map.get(snap_id).containsKey(index)) {
+                return map.get(snap_id).get(index);
+            }
+
+            snap_id--;
+        }
+
+        return 0;
+    }
+}
+
+/**
+ * Your SnapshotArray object will be instantiated and called as such:
+ * SnapshotArray obj = new SnapshotArray(length);
+ * obj.set(index,val);
+ * int param_2 = obj.snap();
+ * int param_3 = obj.get(index,snap_id);
+ */
diff --git a/Medium/Total Hamming Distance.java b/Medium/Total Hamming Distance.java
new file mode 100644
index 00000000..afb641ab
--- /dev/null
+++ b/Medium/Total Hamming Distance.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int totalHammingDistance(int[] nums) {
+        int count = 0;        
+        for (int i = 0; i < 32; i++) {
+            int bitCount = 0;
+            for (int j = 0; j < nums.length; j++) {
+                bitCount += (nums[j] >> i) & 1;
+            }
+            
+            count += bitCount * (nums.length - bitCount);
+        }
+        
+        return count;
+    }
+}

From d24d3a10d0797cf3acc448e7846ef3478734abca Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 7 Aug 2019 08:01:59 -0700
Subject: [PATCH 0023/2175] Added 2 solutions

---
 Medium/Candy Crush.java                | 42 +++++++++++++++++++
 Medium/Time Based Key-Value Store.java | 56 ++++++++++++++++++++++++++
 2 files changed, 98 insertions(+)
 create mode 100644 Medium/Candy Crush.java
 create mode 100644 Medium/Time Based Key-Value Store.java

diff --git a/Medium/Candy Crush.java b/Medium/Candy Crush.java
new file mode 100644
index 00000000..8e60087e
--- /dev/null
+++ b/Medium/Candy Crush.java	
@@ -0,0 +1,42 @@
+class Solution {
+    public int[][] candyCrush(int[][] board) {
+        int rows = board.length;
+        int cols = board[0].length;
+        boolean flag = false;
+        
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j + 2 < cols; j++) {
+                int val = Math.abs(board[i][j]);
+                if (val != 0 && val == Math.abs(board[i][j + 1]) && val == Math.abs(board[i][j + 2])) {
+                    board[i][j] = board[i][j + 1] = board[i][j + 2] = -val;
+                    flag = true;
+                }
+            }
+        }
+        
+        for (int i = 0; i + 2 < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                int val = Math.abs(board[i][j]);
+                if (val != 0 && val == Math.abs(board[i + 1][j]) && val == Math.abs(board[i + 2][j])) {
+                    board[i][j] = board[i + 1][j] = board[i + 2][j] = -val;
+                    flag = true;
+                }
+            }
+        }
+        
+        for (int i = 0; i < cols; ++i) {
+            int rightRow = rows - 1;
+            for (int j = rows - 1; j >= 0; --j) {
+                if (board[j][i] > 0) {
+                    board[rightRow--][i] = board[j][i];
+                }
+            }
+            
+            while (rightRow >= 0) {
+                board[rightRow--][i] = 0;
+            }
+        }
+        
+        return flag ? candyCrush(board) : board;
+    }
+}
diff --git a/Medium/Time Based Key-Value Store.java b/Medium/Time Based Key-Value Store.java
new file mode 100644
index 00000000..8f193508
--- /dev/null
+++ b/Medium/Time Based Key-Value Store.java	
@@ -0,0 +1,56 @@
+class TimeMap {
+
+    /** Initialize your data structure here. */
+    Map<String, List<Entry>> map;
+    public TimeMap() {
+        map = new HashMap<>();
+    }
+
+    public void set(String key, String value, int timestamp) {
+        map.computeIfAbsent(key, k -> new ArrayList<>()).add(new Entry(value, timestamp));
+    }
+
+    public String get(String key, int timestamp) {
+        if (!map.containsKey(key)) {
+            return "";
+        }
+
+        return binarySearch(map.get(key), 0, map.get(key).size() - 1, timestamp);
+    }
+
+    private String binarySearch(List<Entry> entries, int left, int right, int timestamp) {
+        int idx = Integer.MIN_VALUE;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (entries.get(mid).timestamp == timestamp) {
+                return entries.get(mid).value;
+            }
+            else if (entries.get(mid).timestamp > timestamp) {
+                right = mid - 1;
+            }
+            else {
+                idx = Math.max(idx, mid);
+                left = mid + 1;
+            }
+        }
+        
+        return idx == Integer.MIN_VALUE ? "" : entries.get(idx).value;
+    }
+}
+
+class Entry {
+    String value;
+    int timestamp;
+
+    public Entry(String value, int timestamp) {
+        this.value = value;
+        this.timestamp = timestamp;
+    }
+}
+
+/**
+ * Your TimeMap object will be instantiated and called as such:
+ * TimeMap obj = new TimeMap();
+ * obj.set(key,value,timestamp);
+ * String param_2 = obj.get(key,timestamp);
+ */

From fb4ed3683678645892e25b57a5ae5a18e9d5eafd Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 10 Aug 2019 19:27:17 -0700
Subject: [PATCH 0024/2175] Added 2 solutions

---
 ...Is Majority Element in a Sorted Array.java | 13 ++++
 .../Analyze User Website Visit Pattern.java   | 60 +++++++++++++++++++
 2 files changed, 73 insertions(+)
 create mode 100644 Easy/Check If a Number Is Majority Element in a Sorted Array.java
 create mode 100644 Medium/Analyze User Website Visit Pattern.java

diff --git a/Easy/Check If a Number Is Majority Element in a Sorted Array.java b/Easy/Check If a Number Is Majority Element in a Sorted Array.java
new file mode 100644
index 00000000..a5620749
--- /dev/null
+++ b/Easy/Check If a Number Is Majority Element in a Sorted Array.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public boolean isMajorityElement(int[] nums, int target) {
+        if (nums.length == 1) {
+            return nums[0] == target;
+        }
+        
+        if (nums.length == 2) {
+            return nums[0] == target && nums[1] == target;
+        }
+        
+        return nums[nums.length / 2 - 1] == target && nums[nums.length / 2 + 1] == target;
+    }
+}
diff --git a/Medium/Analyze User Website Visit Pattern.java b/Medium/Analyze User Website Visit Pattern.java
new file mode 100644
index 00000000..400c473e
--- /dev/null
+++ b/Medium/Analyze User Website Visit Pattern.java	
@@ -0,0 +1,60 @@
+class Solution {
+    public List<String> mostVisitedPattern(String[] username, int[] timestamp, String[] website) {
+        Map<String, List<Visit>> visitMap = new HashMap<>();
+        int n = username.length;
+        for (int i = 0; i < n; i++) {
+            visitMap.computeIfAbsent(username[i], k -> new ArrayList<>()).add(new Visit(timestamp[i], website[i]));
+        }
+        
+        Map<String, Integer> tripletMap = new HashMap<>();
+        for (String user : visitMap.keySet()) {
+            List<Visit> visits = visitMap.get(user);
+            Collections.sort(visits);
+            Set<String> visited = new HashSet<>();
+            for (int i = 0; i < visits.size(); i++) {
+                for (int j = i + 1; j < visits.size(); j++) {
+                    for (int k = j + 1; k < visits.size(); k++) {
+                        String tempTriplet = visits.get(i).website + "," +  visits.get(j).website + "," + visits.get(k).website;
+                        if (visited.add(tempTriplet)) {
+                            tripletMap.put(tempTriplet, tripletMap.getOrDefault(tempTriplet, 0) + 1);
+                        }
+                    }
+                }
+            }
+        }
+        
+        int maxValue = 0;
+        String res = "";
+        for (String triplet : tripletMap.keySet()) {
+            if (tripletMap.get(triplet) > maxValue) {
+                maxValue = tripletMap.get(triplet);
+                res = triplet;
+            }
+            else if (tripletMap.get(triplet) == maxValue) {
+                if (triplet.compareTo(res) < 0) {
+                    res = triplet;
+                }
+            }
+        }
+        
+        return Arrays.asList(res.split(","));
+    }
+}
+
+class Visit implements Comparable<Visit> {
+    int timestamp;
+    String website;
+    
+    public Visit(int timestamp, String website) {
+        this.timestamp = timestamp;
+        this.website = website;
+    }
+    
+    public String toString() {
+        return timestamp + "->" + website;
+    }
+    
+    public int compareTo(Visit visit) {
+        return this.timestamp - visit.timestamp;
+    }
+}

From 4c9a3a9da9a5b46d0b2124ed56f32f54b9596159 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 18 Aug 2019 09:10:34 -0700
Subject: [PATCH 0025/2175] Added 4 solutions

---
 Easy/Day of the Year.java                     | 37 ++++++++++++++++
 ...ords That Can Be Formed by Characters.java | 33 ++++++++++++++
 Medium/As Far from Land as Possible.java      | 36 +++++++++++++++
 .../Maximum Level Sum of a Binary Tree.java   | 44 +++++++++++++++++++
 4 files changed, 150 insertions(+)
 create mode 100644 Easy/Day of the Year.java
 create mode 100644 Easy/Find Words That Can Be Formed by Characters.java
 create mode 100644 Medium/As Far from Land as Possible.java
 create mode 100644 Medium/Maximum Level Sum of a Binary Tree.java

diff --git a/Easy/Day of the Year.java b/Easy/Day of the Year.java
new file mode 100644
index 00000000..a71ad72e
--- /dev/null
+++ b/Easy/Day of the Year.java	
@@ -0,0 +1,37 @@
+class Solution {
+    List<Integer> daysInMonth = Arrays.asList(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
+    public int dayOfYear(String date) {
+        int year = Integer.parseInt(date.split("-")[0]);
+        int month = Integer.parseInt(date.split("-")[1]);
+        int day = Integer.parseInt(date.split("-")[2]);
+        
+        int numOfDays = getNumOfDays(month, isLeapYear(year));
+        
+        return numOfDays + day;
+    }
+    
+    private boolean isLeapYear(int year) {
+        if (year % 4 == 0) {
+            if (year % 100 == 0) {
+                return year % 400 == 0;
+            }
+            else {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    private int getNumOfDays(int month, boolean isLeapYear) {
+        int numOfDays = 0;
+        for (int i = 1; i < month; i++) {
+            if (i == 2) {
+                numOfDays += isLeapYear ? daysInMonth.get(i - 1) + 1 : daysInMonth.get(i - 1);            
+            } 
+            else {
+                numOfDays += daysInMonth.get(i - 1);
+            }
+        }
+        return numOfDays;
+    }
+}
diff --git a/Easy/Find Words That Can Be Formed by Characters.java b/Easy/Find Words That Can Be Formed by Characters.java
new file mode 100644
index 00000000..80a78c5a
--- /dev/null
+++ b/Easy/Find Words That Can Be Formed by Characters.java	
@@ -0,0 +1,33 @@
+class Solution {
+    public int countCharacters(String[] words, String chars) {
+        int goodWordsLength = 0;
+        Map<Character, Integer> charsMap = getMap(chars);
+
+        for (String word : words) {
+            Map<Character, Integer> wordMap = getMap(word);
+            boolean allFound = true;
+            for (Character character : wordMap.keySet()) {
+                if (charsMap.getOrDefault(character, 0) < wordMap.get(character)) {
+                    allFound = false;
+                    break;
+                }
+            }
+
+            if (allFound) {
+                goodWordsLength +=word.length();
+            }
+        }
+
+
+        return goodWordsLength;
+    }
+
+    private Map<Character, Integer> getMap(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+
+        return map;
+    }
+}
diff --git a/Medium/As Far from Land as Possible.java b/Medium/As Far from Land as Possible.java
new file mode 100644
index 00000000..2096777d
--- /dev/null
+++ b/Medium/As Far from Land as Possible.java	
@@ -0,0 +1,36 @@
+class Solution {
+    public int maxDistance(int[][] grid) {
+        if (grid.length == 0 || grid[0].length == 0) {
+            return -1;
+        }
+        int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+        boolean[][] visited = new boolean[grid.length][grid[0].length];
+        Queue<int[]> queue = new LinkedList<>();
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1) {
+                    queue.add(new int[]{i, j});
+                    visited[i][j] = true;
+                }
+            }
+        }
+        int maxDist = -1;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] curr = queue.remove();
+                for (int[] dir : dirs) {
+                    int x = curr[0] + dir[0];
+                    int y = curr[1] + dir[1];
+                    if (x >= 0 &&  x < grid.length && y >= 0 && y < grid[0].length && !visited[x][y] && grid[x][y] == 0) {
+                        visited[x][y] = true;
+                        queue.add(new int[]{x, y});
+                    }
+                }
+            }
+            maxDist++;
+        }
+
+        return maxDist == 0 ? -1 : maxDist;
+    }
+}
diff --git a/Medium/Maximum Level Sum of a Binary Tree.java b/Medium/Maximum Level Sum of a Binary Tree.java
new file mode 100644
index 00000000..705aae45
--- /dev/null
+++ b/Medium/Maximum Level Sum of a Binary Tree.java	
@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int maxLevelSum(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        int maxSum = 0;
+        int maxLevel = 1;
+        int currLevel = 1;
+        
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            int tempSum = 0;
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                tempSum += removed.val;
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            if (maxSum < tempSum) {
+                maxSum = tempSum;
+                maxLevel = currLevel;
+            }
+            currLevel++;
+        }
+        
+        return maxLevel;
+    }
+}

From 22d63e2c37b6ac61a4a303ac6fa495c253032946 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 24 Aug 2019 18:56:48 -0700
Subject: [PATCH 0026/2175] Added 5 solutions

---
 Easy/Largest Triangle Area.java               | 20 ++++++
 Easy/Single-Row Keyboard.java                 | 17 +++++
 Medium/Design File System.java                | 30 +++++++++
 .../Number of Dice Rolls With Target Sum.java | 23 +++++++
 Medium/Online Election.java                   | 63 +++++++++++++++++++
 5 files changed, 153 insertions(+)
 create mode 100644 Easy/Largest Triangle Area.java
 create mode 100644 Easy/Single-Row Keyboard.java
 create mode 100644 Medium/Design File System.java
 create mode 100644 Medium/Number of Dice Rolls With Target Sum.java
 create mode 100644 Medium/Online Election.java

diff --git a/Easy/Largest Triangle Area.java b/Easy/Largest Triangle Area.java
new file mode 100644
index 00000000..92b281d4
--- /dev/null
+++ b/Easy/Largest Triangle Area.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public double largestTriangleArea(int[][] points) {
+        int n = points.length;
+        double maxArea = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                for (int k = j + 1; k < n; k++) {
+                    maxArea = Math.max(maxArea, getArea(points[i], points[j], points[k]));
+                }
+            }
+        }
+        
+        return maxArea;
+    }
+    
+    private double getArea(int[] P, int[] Q, int[] R) {
+        return 0.5 * Math.abs(P[0] * Q[1] + Q[0] * R[1] + R[0] * P[1]
+                             -P[1] * Q[0] - Q[1] * R[0] - R[1] * P[0]);
+    }
+}
diff --git a/Easy/Single-Row Keyboard.java b/Easy/Single-Row Keyboard.java
new file mode 100644
index 00000000..c290c5f3
--- /dev/null
+++ b/Easy/Single-Row Keyboard.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int calculateTime(String keyboard, String word) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < keyboard.length(); i++) {
+            map.put(keyboard.charAt(i), i);
+        }
+        
+        int currPos = 0;
+        int totalTime = 0;
+        for (char c : word.toCharArray()) {
+            totalTime += Math.abs(currPos - map.get(c));
+            currPos = map.get(c);
+        }
+        
+        return totalTime;
+    }
+}
diff --git a/Medium/Design File System.java b/Medium/Design File System.java
new file mode 100644
index 00000000..9dbb0b39
--- /dev/null
+++ b/Medium/Design File System.java	
@@ -0,0 +1,30 @@
+class FileSystem {
+
+    Map<String, Integer> map;
+    public FileSystem() {
+        map = new HashMap<>();
+    }
+    
+    public boolean create(String path, int value) {
+        if (map.containsKey(path)) {
+            return false;
+        }
+        int lastIdx = path.lastIndexOf('/');
+        if (lastIdx != 0 && !map.containsKey(path.substring(0, lastIdx))) {
+            return false;
+        }    
+        map.put(path, value);
+        return true;
+    }
+    
+    public int get(String path) {
+        return map.getOrDefault(path, -1);
+    }
+}
+
+/**
+ * Your FileSystem object will be instantiated and called as such:
+ * FileSystem obj = new FileSystem();
+ * boolean param_1 = obj.create(path,value);
+ * int param_2 = obj.get(path);
+ */
diff --git a/Medium/Number of Dice Rolls With Target Sum.java b/Medium/Number of Dice Rolls With Target Sum.java
new file mode 100644
index 00000000..eb157eb6
--- /dev/null
+++ b/Medium/Number of Dice Rolls With Target Sum.java	
@@ -0,0 +1,23 @@
+class Solution {
+    int MOD = 1000000007;
+    public int numRollsToTarget(int d, int f, int target) {
+        Integer[][] dp = new Integer[d + 1][target + 1];
+        return helper(d, f, target, dp);
+    }
+    
+    private int helper(int d, int f, int target, Integer[][] dp) {
+        if (d == 0 || target <= 0) {
+            return d == target ? 1 : 0;
+        }
+        if (dp[d][target] != null) {
+            return dp[d][target];
+        }
+        
+        dp[d][target] = 0;
+        for (int i = 1; i <= f; i++) {
+            dp[d][target] = (dp[d][target] + helper(d - 1, f, target - i, dp)) % MOD; 
+        }
+        
+        return dp[d][target];
+    }
+}
diff --git a/Medium/Online Election.java b/Medium/Online Election.java
new file mode 100644
index 00000000..056879d5
--- /dev/null
+++ b/Medium/Online Election.java	
@@ -0,0 +1,63 @@
+class TopVotedCandidate {
+
+    Map<Integer, Integer> voteCount;
+    Map<Integer, Integer> timeCount;
+    int currLeaderCount;
+    List<Winner> winners;
+
+    public TopVotedCandidate(int[] persons, int[] times) {
+        voteCount = new HashMap<>();
+        timeCount = new HashMap<>();
+        currLeaderCount = 0;
+        winners = new ArrayList<>();
+        
+        for (int i = 0; i < persons.length; i++) {
+            boolean isPresent = voteCount.containsKey(persons[i]);
+            voteCount.put(persons[i], voteCount.getOrDefault(persons[i], 0) + 1);
+            timeCount.put(persons[i], times[i]);
+            if (voteCount.get(persons[i]) >= currLeaderCount) {
+                winners.add(new Winner(persons[i], times[i]));
+                currLeaderCount = Math.max(currLeaderCount, voteCount.get(persons[i]));
+            }
+        }
+    }
+
+    public int q(int t) {
+        return winners.get(binarySearchHelper(winners, 0, winners.size() - 1, t)).val;
+    }
+
+    private int binarySearchHelper(List<Winner> winners, int left, int right, int target) {
+        int idx = winners.size();
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (winners.get(mid).time == target) {
+                idx = mid;
+                break;
+            }
+            else if (winners.get(mid).time < target) {
+                idx = mid;
+                left = mid + 1;
+            }
+            else {
+                right = mid - 1;
+            }
+        }
+        
+        return idx == winners.size() ? 0 : idx;
+    }
+}
+
+class Winner {
+    int val;
+    int time;
+
+    public Winner(int val, int time) {
+        this.val = val;
+        this.time = time;
+    }
+}
+/**
+ * Your TopVotedCandidate object will be instantiated and called as such:
+ * TopVotedCandidate obj = new TopVotedCandidate(persons, times);
+ * int param_1 = obj.q(t);
+ */

From f414760478e968954a1106367a1f3476297b3d1a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 4 Sep 2019 19:25:58 -0700
Subject: [PATCH 0027/2175] Added 2 solutions

---
 ...y Frequency of the Smallest Character.java | 45 +++++++++++++++++++
 Easy/Diet Plan Performance.java               | 27 +++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 Easy/Compare Strings by Frequency of the Smallest Character.java
 create mode 100644 Easy/Diet Plan Performance.java

diff --git a/Easy/Compare Strings by Frequency of the Smallest Character.java b/Easy/Compare Strings by Frequency of the Smallest Character.java
new file mode 100644
index 00000000..a65ff4aa
--- /dev/null
+++ b/Easy/Compare Strings by Frequency of the Smallest Character.java	
@@ -0,0 +1,45 @@
+class Solution {
+    public int[] numSmallerByFrequency(String[] queries, String[] words) {
+        List<Integer> list = new ArrayList<>();
+        for (String word : words) {
+            list.add(getMinWordFreq(word));
+        }
+        Collections.sort(list);
+        int[] ans = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            int minCount = getMinWordFreq(queries[i]);
+            int idx = 0;
+            ans[i] = binarySearch(minCount, list);
+        }
+        return ans;
+    }
+    
+    private int binarySearch(int target, List<Integer> list) {
+        int left = 0;
+        int right = list.size() - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (list.get(mid) <= target) {
+                left = mid + 1;
+            }
+            else {
+                right = mid - 1;
+            }
+        }
+        
+        return list.size() - left;
+    }
+    
+    private int getMinWordFreq(String word) {
+        int[] counter = new int[26];
+        for (char c : word.toCharArray()) {
+            counter[c - 'a']++;
+        }
+        for (int i = 0; i < 26; i++) {
+            if (counter[i] != 0) {
+                return counter[i];
+            }
+        }
+        return 0;
+    }
+}
diff --git a/Easy/Diet Plan Performance.java b/Easy/Diet Plan Performance.java
new file mode 100644
index 00000000..719e5797
--- /dev/null
+++ b/Easy/Diet Plan Performance.java	
@@ -0,0 +1,27 @@
+class Solution {
+    int points;
+    public int dietPlanPerformance(int[] calories, int k, int lower, int upper) {
+        points = 0;
+        int totalCal = 0;
+        int start = 0;
+        for (int i = 0; i < k; i++) {
+            totalCal += calories[i];
+        }
+        for (int i = k; i < calories.length; i++) {    
+            updatePoints(totalCal, lower, upper);
+            totalCal -= calories[start++];
+            totalCal += calories[i];
+        }
+        updatePoints(totalCal, lower, upper);
+        return points;
+    }
+    
+    private void updatePoints(int currCal, int lower, int upper) {
+        if (currCal < lower) {
+            points--;
+        }
+        if (currCal > upper) {
+            points++;
+        }
+    }
+}

From 549d555d25da584f8e0f9a86d561d671784fb74e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 11 Sep 2019 08:25:36 -0700
Subject: [PATCH 0028/2175] Added 2 solutions

---
 ...strings with Only One Distinct Letter.java | 16 ++++++++++
 Easy/Distance Between Bus Stops.java          | 31 +++++++++++++++++++
 2 files changed, 47 insertions(+)
 create mode 100644 Easy/Count Substrings with Only One Distinct Letter.java
 create mode 100644 Easy/Distance Between Bus Stops.java

diff --git a/Easy/Count Substrings with Only One Distinct Letter.java b/Easy/Count Substrings with Only One Distinct Letter.java
new file mode 100644
index 00000000..4ef2a20f
--- /dev/null
+++ b/Easy/Count Substrings with Only One Distinct Letter.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int countLetters(String S) {
+        int count = 0;
+        int result = 1;
+        for (int i = 1; i < S.length(); i++) {
+            if (S.charAt(i) == S.charAt(i- 1)) {
+                result++;
+            }
+            else {
+                count += (result * (result + 1)) / 2;
+                result = 1;
+            }
+        }
+        return count + (result * (result + 1)) / 2;
+    }
+}
diff --git a/Easy/Distance Between Bus Stops.java b/Easy/Distance Between Bus Stops.java
new file mode 100644
index 00000000..e387e92b
--- /dev/null
+++ b/Easy/Distance Between Bus Stops.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int distanceBetweenBusStops(int[] distance, int start, int destination) {
+        if (start == destination) {
+            return 0;
+        }
+        int n = distance.length;
+        int actualStart = Math.min(start, destination);
+        int actualDestination = Math.max(start, destination);
+        return Math.min(
+            getStraightDistance(distance, actualStart, actualDestination, n), 
+            getReverseDistance(distance, actualDestination, actualStart, n)
+        );
+    }
+    
+    private int getStraightDistance(int[] distance, int start, int end, int n) {
+        int dist = 0;
+        while (start != end) {
+            dist += distance[start++];
+        }
+        return dist;
+    }
+    
+    private int getReverseDistance(int[] distance, int end, int start, int n) {
+        int dist = 0;
+        while (end != start) {
+            dist += distance[end++];
+            end = end % n;
+        }
+        return dist;
+    }
+}

From 7e9c8e44d360978371a6ac12aaa348f0d01e7cf9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 15 Sep 2019 08:20:07 -0700
Subject: [PATCH 0029/2175] Added 2 solutions & updated 1 solution

---
 Easy/Maximum Number of Balloons.java          | 15 +++++++++
 Easy/Subtree of Another Tree.java             | 33 ++++++++++---------
 ...ings Between Each Pair of Parentheses.java | 17 ++++++++++
 3 files changed, 49 insertions(+), 16 deletions(-)
 create mode 100644 Easy/Maximum Number of Balloons.java
 create mode 100644 Medium/Reverse Substrings Between Each Pair of Parentheses.java

diff --git a/Easy/Maximum Number of Balloons.java b/Easy/Maximum Number of Balloons.java
new file mode 100644
index 00000000..b0553373
--- /dev/null
+++ b/Easy/Maximum Number of Balloons.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int maxNumberOfBalloons(String text) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (Character c : text.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        int maxCount = 0;
+        maxCount = map.getOrDefault('l', 0) / 2;
+        maxCount = Math.min(map.getOrDefault('o', 0) / 2, maxCount);
+        maxCount = Math.min(map.getOrDefault('b', 0), maxCount);
+        maxCount = Math.min(map.getOrDefault('a', 0), maxCount);
+        maxCount = Math.min(map.getOrDefault('n', 0), maxCount);
+        return maxCount;
+    }
+}
diff --git a/Easy/Subtree of Another Tree.java b/Easy/Subtree of Another Tree.java
index 7c565ce5..f132ee85 100644
--- a/Easy/Subtree of Another Tree.java	
+++ b/Easy/Subtree of Another Tree.java	
@@ -9,24 +9,25 @@
  */
 class Solution {
     public boolean isSubtree(TreeNode s, TreeNode t) {
-        return traverseAndString(s).contains(traverseAndString(t));
-    }
-    
-    public String traverseAndString(TreeNode root) {
-        StringBuilder res = new StringBuilder();
-        traverse(root, res);
-        return res.toString();
+        if (s == null) {
+            return false;
+        }
+        if (helper(s, t)) {
+            return true;
+        }
+        return isSubtree(s.left, t) || isSubtree(s.right, t);
     }
     
-    public void traverse(TreeNode root, StringBuilder res) {
-        
-        if (root == null) {
-            res.append("-");
-            return;
+    private boolean helper(TreeNode s, TreeNode t) {
+        if (s == null && t == null) {
+            return true;
+        }
+        if ((s == null && t != null) || (s != null && t == null)) {
+            return false;
+        }
+        if (s.val != t.val) {
+            return false;
         }
-        
-        traverse(root.left, res);
-        traverse(root.right, res);
-        res.append(String.valueOf(root.val) + ",");
+        return helper(s.left, t.left) && helper(s.right, t.right);
     }
 }
diff --git a/Medium/Reverse Substrings Between Each Pair of Parentheses.java b/Medium/Reverse Substrings Between Each Pair of Parentheses.java
new file mode 100644
index 00000000..082685e4
--- /dev/null
+++ b/Medium/Reverse Substrings Between Each Pair of Parentheses.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public String reverseParentheses(String s) {
+        int start = 0;
+        int end = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == '(') {
+                start = i;
+            }
+            if (s.charAt(i) == ')') {
+                end = i;
+                StringBuilder sb = new StringBuilder(s.substring(start + 1, end)).reverse();
+                return reverseParentheses(s.substring(0, start) + sb.toString() + s.substring(end + 1));
+            }
+        }
+        return s;
+    }
+}

From 0fcd76aadb558ea9ecd0b92800d6e9daf907a15a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 25 Sep 2019 08:23:21 -0700
Subject: [PATCH 0030/2175] Added 2 solutions

---
 ... Many Apples Can You Put into the Basket.java | 15 +++++++++++++++
 Easy/Minimum Absolute Difference.java            | 16 ++++++++++++++++
 2 files changed, 31 insertions(+)
 create mode 100644 Easy/How Many Apples Can You Put into the Basket.java
 create mode 100644 Easy/Minimum Absolute Difference.java

diff --git a/Easy/How Many Apples Can You Put into the Basket.java b/Easy/How Many Apples Can You Put into the Basket.java
new file mode 100644
index 00000000..99345d35
--- /dev/null
+++ b/Easy/How Many Apples Can You Put into the Basket.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int maxNumberOfApples(int[] arr) {
+        Arrays.sort(arr);
+        int total = 0;
+        int count = 0;
+        for (int i = 0; i < arr.length; i++) {
+            total += arr[i];
+            if (total > 5000) {
+                break;
+            }
+            count++;
+        }
+        return count;
+    }
+}
diff --git a/Easy/Minimum Absolute Difference.java b/Easy/Minimum Absolute Difference.java
new file mode 100644
index 00000000..48ff75e9
--- /dev/null
+++ b/Easy/Minimum Absolute Difference.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public List<List<Integer>> minimumAbsDifference(int[] arr) {
+        Arrays.sort(arr);
+        int minDiff = arr[1] - arr[0];
+        for (int i = 2; i < arr.length; i++) {
+            minDiff = Math.min(minDiff, arr[i] - arr[i - 1]);
+        }
+        List<List<Integer>> ans = new ArrayList<>();
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[i] - arr[i - 1] == minDiff) {
+                ans.add(Arrays.asList(arr[i - 1], arr[i]));
+            } 
+        }
+        return ans;
+    }
+}

From 04df94d465ed408c50f2452cb9d4aaf3dcdaac87 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 29 Sep 2019 13:37:08 -0700
Subject: [PATCH 0031/2175] Added Unique Number of Occurrences.java

---
 Easy/Unique Number of Occurrences.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Unique Number of Occurrences.java

diff --git a/Easy/Unique Number of Occurrences.java b/Easy/Unique Number of Occurrences.java
new file mode 100644
index 00000000..fb61d166
--- /dev/null
+++ b/Easy/Unique Number of Occurrences.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean uniqueOccurrences(int[] arr) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : arr) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        Set<Integer> set = new HashSet<>(map.values());
+        return map.size() == set.size();
+    }
+}

From 0c0489a56dad376bbe1d4e684bda32da2120237a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Oct 2019 20:40:41 -0700
Subject: [PATCH 0032/2175] Update README.md

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index 41f80fd8..9aeb16b7 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,4 @@
 # LeetCode-Java-Solutions
 Repository to store solutions to various problems in Leetcode practice and weekly contests
 
-[My Leetcode Profile](https://leetcode.com/varunu28/)
-
 ![image](https://cdn-images-1.medium.com/max/1360/1*5qdPLs4x9TuabvQJwu7iuA.png)

From 2ab62d11950b80c99ba24af1ad1cd0ef8d5fbe86 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 19 Oct 2019 22:16:14 -0700
Subject: [PATCH 0033/2175] Update Design Tic-Tac-Toe.java

---
 Medium/Design Tic-Tac-Toe.java | 130 ++++++++-------------------------
 1 file changed, 30 insertions(+), 100 deletions(-)

diff --git a/Medium/Design Tic-Tac-Toe.java b/Medium/Design Tic-Tac-Toe.java
index defa38c2..25187bbe 100644
--- a/Medium/Design Tic-Tac-Toe.java	
+++ b/Medium/Design Tic-Tac-Toe.java	
@@ -1,13 +1,18 @@
 class TicTacToe {
 
     /** Initialize your data structure here. */
-    int[][] board;
-    int n;
-    boolean win;
+    private int[] rows;
+    private int[] cols;
+    private int leftDiagCount;
+    private int rightDiagCount;
+    private int n;
 
     public TicTacToe(int n) {
         this.n = n;
-        board = new int[n][n];
+        this.rows = new int[n];
+        this.cols = new int[n];
+        leftDiagCount = 0;
+        rightDiagCount = 0;
     }
 
     /** Player {player} makes a move at ({row}, {col}).
@@ -19,104 +24,29 @@ public TicTacToe(int n) {
      1: Player 1 wins.
      2: Player 2 wins. */
     public int move(int row, int col, int player) {
-        if (win) {
-            return 0;
-        }
-
-        board[row][col] = player;
-
-        boolean cCheck = columnCheck(col, n, player);
-        boolean rCheck = rowCheck(row, n, player);
-        boolean diagCheck = diagonalCheck(row, col, n, player);
-
-        if (cCheck || rCheck  || diagCheck) {
-            win = true;
+        int moveValue = player == 1 ? 1 : -1;
+        rows[row] += moveValue;
+        cols[col] += moveValue;
+        if (row == col) {
+            leftDiagCount += moveValue;
+        }
+        if (col == n - row - 1) {
+            rightDiagCount += moveValue;
+        }
+        if (
+            Math.abs(rows[row]) == n ||
+            Math.abs(cols[col]) == n ||
+            Math.abs(leftDiagCount) == n || 
+            Math.abs(rightDiagCount) == n
+        ) {
             return player;
         }
-
         return 0;
     }
-
-    private boolean diagonalCheck(int row, int col, int n, int player) {
-        int count = 0;
-
-        int rowNum = row;
-        int colNum = col;
-
-        while (rowNum < n && colNum < n) {
-            if (board[rowNum][colNum] == player) {
-                count++;
-            }
-
-            rowNum++;
-            colNum++;
-        }
-
-        rowNum = row-1;
-        colNum = col-1;
-
-        while (rowNum >= 0 && colNum >= 0) {
-            if (board[rowNum][colNum] == player) {
-                count++;
-            }
-
-            rowNum--;
-            colNum--;
-        }
-
-        if (count == n) {
-            return true;
-        }
-
-        count = 0;
-        rowNum = row;
-        colNum = col;
-
-        while (rowNum >= 0 && colNum < n) {
-            if (board[rowNum][colNum] == player) {
-                count++;
-            }
-
-            rowNum--;
-            colNum++;
-        }
-
-        rowNum = row;
-        colNum = col;
-
-        while (rowNum < n && colNum >= 0) {
-            if (board[rowNum][colNum] == player) {
-                count++;
-            }
-
-            rowNum++;
-            colNum--;
-        }
-
-        if (count == n+1) {
-            return true;
-        }
-
-        return false;
-    }
-
-    private boolean rowCheck(int row, int n, int player) {
-        for (int i=0; i<n;i++) {
-            if (board[row][i] != player) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    private boolean columnCheck(int col, int n, int player) {
-        for (int i=0; i<n; i++) {
-            if (board[i][col] != player) {
-                return false;
-            }
-        }
-
-        return true;
-    }
 }
+
+/**
+ * Your TicTacToe object will be instantiated and called as such:
+ * TicTacToe obj = new TicTacToe(n);
+ * int param_1 = obj.move(row,col,player);
+ */

From 7a448d00ac96b26684f6d6a8ab5c53027b3d9fd0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Oct 2019 20:32:25 -0700
Subject: [PATCH 0034/2175] Create Web Crawler.java

---
 Medium/Web Crawler.java | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Web Crawler.java

diff --git a/Medium/Web Crawler.java b/Medium/Web Crawler.java
new file mode 100644
index 00000000..2eafccb7
--- /dev/null
+++ b/Medium/Web Crawler.java	
@@ -0,0 +1,31 @@
+/**
+ * // This is the HtmlParser's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface HtmlParser {
+ *     public List<String> getUrls(String url) {}
+ * }
+ */
+class Solution {
+    public List<String> crawl(String startUrl, HtmlParser htmlParser) {
+        Set<String> visited = new HashSet<>();
+        Stack<String> stack = new Stack<>();
+        stack.push(startUrl);
+        String hostname = getHostname(startUrl);
+        while(!stack.isEmpty()) {
+            String popped = stack.pop();
+            visited.add(popped);
+            List<String> connectedUrls = htmlParser.getUrls(popped);
+            for (String url : connectedUrls) {
+                if (!visited.contains(url) && url.contains(hostname)) {
+                    stack.push(url);
+                }
+            }
+        }
+        return new ArrayList<>(visited);
+    }
+    
+    private String getHostname(String url) {
+        String[] splits = url.split("/");
+        return splits[2];
+    }
+}

From 93a24bcbcff0100b1cdb1fbc63191ea25dfe2a3c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Oct 2019 19:46:46 -0700
Subject: [PATCH 0035/2175] Create Missing Number In Arithmetic
 Progression.java

---
 Easy/Missing Number In Arithmetic Progression.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Missing Number In Arithmetic Progression.java

diff --git a/Easy/Missing Number In Arithmetic Progression.java b/Easy/Missing Number In Arithmetic Progression.java
new file mode 100644
index 00000000..fa657f76
--- /dev/null
+++ b/Easy/Missing Number In Arithmetic Progression.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public int missingNumber(int[] arr) {
+        int n = arr.length;
+        int d = (arr[n - 1] - arr[0]) / n;
+        for (int i = 1; i < n; i++) {
+            if (arr[i] - arr[i - 1] != d) {
+                return arr[i - 1] + d;
+            }
+        }
+        return d;
+    }
+}

From c9631caee8b2372117421dffc03896ce8bdf72f3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Oct 2019 07:11:55 -0700
Subject: [PATCH 0036/2175] Create Odd Even Jump.java

---
 Hard/Odd Even Jump.java | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Hard/Odd Even Jump.java

diff --git a/Hard/Odd Even Jump.java b/Hard/Odd Even Jump.java
new file mode 100644
index 00000000..5c10ce6a
--- /dev/null
+++ b/Hard/Odd Even Jump.java	
@@ -0,0 +1,37 @@
+class Solution {
+    public int oddEvenJumps(int[] A) {
+        if (A.length <= 1) {
+            return A.length;
+        }
+        boolean[] odd = new boolean[A.length];
+        boolean[] even = new boolean[A.length];
+        odd[A.length - 1] = even[A.length - 1] = true;
+        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
+        treeMap.put(A[A.length - 1], A.length - 1);
+        for (int i = A.length - 2; i >= 0; i--) {
+            int val = A[i];
+            if (treeMap.containsKey(val)) {
+                odd[i] = even[treeMap.get(val)];
+                even[i] = odd[treeMap.get(val)];
+            }
+            else {
+                Integer lower = treeMap.lowerKey(val);
+                Integer higher = treeMap.higherKey(val);
+                if (lower != null) {
+                    even[i] = odd[treeMap.get(lower)];
+                }
+                if (higher != null) {
+                    odd[i] = even[treeMap.get(higher)];
+                }
+            }
+            treeMap.put(val, i);
+        }
+        int count = 0;
+        for (boolean b : odd) {
+            if (b) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

From 6f3680d19d5c1a4c9d77488948f2b69453e76630 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Oct 2019 07:15:14 -0700
Subject: [PATCH 0037/2175] Update Odd Even Jump.java

---
 Hard/Odd Even Jump.java | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/Hard/Odd Even Jump.java b/Hard/Odd Even Jump.java
index 5c10ce6a..8e516f6c 100644
--- a/Hard/Odd Even Jump.java	
+++ b/Hard/Odd Even Jump.java	
@@ -8,6 +8,7 @@ public int oddEvenJumps(int[] A) {
         odd[A.length - 1] = even[A.length - 1] = true;
         TreeMap<Integer, Integer> treeMap = new TreeMap<>();
         treeMap.put(A[A.length - 1], A.length - 1);
+        int count = 0;
         for (int i = A.length - 2; i >= 0; i--) {
             int val = A[i];
             if (treeMap.containsKey(val)) {
@@ -25,13 +26,8 @@ public int oddEvenJumps(int[] A) {
                 }
             }
             treeMap.put(val, i);
+            count += odd[i] ? 1 : 0;
         }
-        int count = 0;
-        for (boolean b : odd) {
-            if (b) {
-                count++;
-            }
-        }
-        return count;
+        return count + 1;
     }
 }

From 319c09bd1e991307277ef55bfad03fe6f367decf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 30 Oct 2019 21:24:57 -0700
Subject: [PATCH 0038/2175] Create Split a String in Balanced Strings.java

---
 Easy/Split a String in Balanced Strings.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Split a String in Balanced Strings.java

diff --git a/Easy/Split a String in Balanced Strings.java b/Easy/Split a String in Balanced Strings.java
new file mode 100644
index 00000000..2488bb79
--- /dev/null
+++ b/Easy/Split a String in Balanced Strings.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int balancedStringSplit(String s) {
+        int count = 0;
+        int val = 0;
+        for (char c : s.toCharArray()) {
+            val += c == 'L' ? -1 : 1;
+            if (val == 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

From db2da8368255a4e191300e5657fc70256fe2e6bc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Nov 2019 14:42:45 -0800
Subject: [PATCH 0039/2175] README cleanup and question index creation

---
 Easy/Easy.md     | 284 ++++++++++++++++++++++++++++++++++++++++
 Hard/Hard.md     |  56 ++++++++
 Medium/Medium.md | 333 +++++++++++++++++++++++++++++++++++++++++++++++
 README.md        |  11 +-
 script.py        |  29 +++++
 5 files changed, 710 insertions(+), 3 deletions(-)
 create mode 100644 Easy/Easy.md
 create mode 100644 Hard/Hard.md
 create mode 100644 Medium/Medium.md
 create mode 100755 script.py

diff --git a/Easy/Easy.md b/Easy/Easy.md
new file mode 100644
index 00000000..ff6c3a2e
--- /dev/null
+++ b/Easy/Easy.md
@@ -0,0 +1,284 @@
+# Easy LeetCode-Java-Solutions 
+S.no | Coding Problem 
+--- | --- 
+1|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's Triangle.java)
+2|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMeeting Rooms.java)
+3|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Bits.java)
+4|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCousins in Binary Tree.java)
+5|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyKeyboard Row.java)
+6|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest Unique Number.java)
+7|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAssign Cookies.java)
+8|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Depth of N-ary Tree.java)
+9|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount and Say.java)
+10|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArranging Coins.java)
+11|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Number of Balloons.java)
+12|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConstruct the rectangle.java)
+13|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMagic Squares In Grid.java)
+14|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMatrix Cells in Distance Order.java)
+15|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy1-bit and 2-bit Characters.java)
+16|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind the difference.java)
+17|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFactorial Trailing Zeroes.java)
+18|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySentence Similarity.java)
+19|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest Number At Least Twice of Others.java)
+20|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax Area of Island.java)
+21|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Palindrome.java)
+22|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Word Distance III.java)
+23|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyString Compression.java)
+24|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easytrailing_zeroes.java)
+25|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGreatest Common Divisor of Strings.java)
+26|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum IV - Input is a BST.java)
+27|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLinked List Cycle.java)
+28|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDelete node in a linked list.java)
+29|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyExcel Sheet Column Number.java)
+30|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPairs of Songs With Total Durations Divisible by 60.java)
+31|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove Linked List Elements.java)
+32|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySingle-Row Keyboard.java)
+33|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMissing Number In Arithmetic Progression.java)
+34|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum of left leaves.java)
+35|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign Compressed String Iterator.java)
+36|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Boomerang.java)
+37|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlip Game.java)
+38|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAvailable Captures for Rook.java)
+39|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyStrobogrammatic Number.java)
+40|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd to Array-Form of Integer.java)
+41|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse words in a String III.java)
+42|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLowest Common Ancestor of a Binary Search Tree.java)
+43|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind Mode in Binary Search Tree.java)
+44|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of 1 bits.java)
+45|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIncreasing Order Search Tree.java)
+46|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyOccurrences After Bigram.java)
+47|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign HashSet.java)
+48|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyExcel Sheet Column Title.java)
+49|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind All Numbers Disappeared in an Array.java)
+50|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easysum_of_two_integers.java)
+51|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLogger Rate Limiter.java)
+52|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath Sum.java)
+53|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySearch Insert Position.java)
+54|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySearch in a Binary Search Tree.java)
+55|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of Equivalent Domino Pairs.java)
+56|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyJewels and Stones.java)
+57|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique Email Addresses.java)
+58|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRoman to Integer.java)
+59|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount Primes.java)
+60|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyComplement of Base 10 Integer.java)
+61|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Subarray.java)
+62|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easycontains_duplicates.java)
+63|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of Boomerangs.java)
+64|[Valid Parantheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Parantheses.java)
+65|[remove_duplicates_sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyremove_duplicates_sorted.java)
+66|[Sum of square numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum of square numbers.java)
+67|[add_digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyadd_digit.java)
+68|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLetter Case Permutation.java)
+69|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTranspose Matrix.java)
+70|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Number with Alternating Bits.java)
+71|[Power of three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPower of three.java)
+72|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove All Adjacent Duplicates In String.java)
+73|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Continuous Increasing Subsequence.java)
+74|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome Permutation.java)
+75|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Word Sequence.java)
+76|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPowerful Integers.java)
+77|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIsomorphic Strings.java)
+78|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUncommon Words from Two Sentences.java)
+79|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign HashMap.java)
+80|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBackspace String Compare.java)
+81|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax Consecutive Ones.java)
+82|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHappy Number.java)
+83|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath Sum III.java)
+84|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Word Distance.java)
+85|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Prefix Divisible By 5.java)
+86|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLeaf-Similar Trees.java)
+87|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNested List Weight Sum.java)
+88|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGuess Number Higher or Lower.java)
+89|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMonotonic Array.java)
+90|[ugly_number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyugly_number.java)
+91|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of Days in a Month.java)
+92|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum III - Data Structure Design.java)
+93|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIsland Perimeter.java)
+94|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySqrtX.java)
+95|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFair Candy Swap.java)
+96|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHeaters.java)
+97|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTrim a Binary Search Tree.java)
+98|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFirst Bad Version.java)
+99|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySingle Number.java)
+100|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyClosest Binary Search Tree Value.java)
+101|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Word Distance II.java)
+102|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySymmetric Tree.java)
+103|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum Absolute Difference.java)
+104|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Palindrome II.java)
+105|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRead N characters Given Read4.java)
+106|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary Tree Level Order Traversal.java)
+107|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse String II.java)
+108|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDegree of an array.java)
+109|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind All Anagrams in a String.java)
+110|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubmission Detail.java)
+111|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Tree Paths.java)
+112|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotate Array.java)
+113|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDay of the Year.java)
+114|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySet Mismatch.java)
+115|[majority_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easymajority_element.java)
+116|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber Complement.java)
+117|[power_of_2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easypower_of_2.java)
+118|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCan Place Flowers.java)
+119|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest Perimeter Triangle.java)
+120|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRelative ranks.java)
+121|[Convert BST to greater tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert BST to greater tree.java)
+122|[valid_anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyvalid_anagrams.java)
+123|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLicense Key Formatting.java)
+124|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyVerifying an Alien Dictionary.java)
+125|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDiameter of Binary Tree.java)
+126|[first_unique_character_in_a_string](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyfirst_unique_character_in_a_string.java)
+127|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMoving Average from Data Stream.java)
+128|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDiet Plan Performance.java)
+129|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubdomain Visit Count.java)
+130|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDuplicate Zeros.java)
+131|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySame Tree.java)
+132|[FizzBuzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFizzBuzz.java)
+133|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBuddy Strings.java)
+134|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyThird Maximum Number.java)
+135|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's Triangle II.java)
+136|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyWord Pattern.java)
+137|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHamming Distance.java)
+138|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum Distance Between BST Nodes.java)
+139|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind Words That Can Be Formed by Characters.java)
+140|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDefanging an IP Address.java)
+141|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Vowels of a String.java)
+142|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBalanced Binary Tree.java)
+143|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHow Many Apples Can You Put into the Basket.java)
+144|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyString Without AAA or BBB.java)
+145|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement Queue using Stacks.java)
+146|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBaseball Game.java)
+147|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyrange_addition_II.java)
+148|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign Linked List.java)
+149|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert a number to hexadecimal.java)
+150|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyToeplitz Matrix.java)
+151|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-th Tribonacci Number.java)
+152|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyKth Largest Element in a Stream.java)
+153|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary Tree Preorder Traversal.java)
+154|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPaint House.java)
+155|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPeak Index in a Mountain Array.java)
+156|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Search.java)
+157|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum Less Than K.java)
+158|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum depth of Binary tree.java)
+159|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotting Oranges.java)
+160|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArmstrong Number.java)
+161|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBest time to buy & sell a stock II.java)
+162|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBase 7.java)
+163|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Univalue Path.java)
+164|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRepeated Substring Pattern.java)
+165|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Distance in Arrays.java)
+166|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRelative Sort Array.java)
+167|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique Number of Occurrences.java)
+168|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLast Stone Weight.java)
+169|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest Triangle Area.java)
+170|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMin Cost Climbing Stairs.java)
+171|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of Lines To Write String.java)
+172|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDetect Capital.java)
+173|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum II.java)
+174|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistance Between Bus Stops.java)
+175|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum of Digits in the Minimum Number.java)
+176|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCheck If a Number Is Majority Element in a Sorted Array.java)
+177|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge two binary trees.java)
+178|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConstruct String from Binary Tree.java)
+179|[Merge Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge Sorted Arrays.java)
+180|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-Repeated Element in Size 2N Array.java)
+181|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIntersection of two arrays II.java)
+182|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo City Scheduling.java)
+183|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHigh Five.java)
+184|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyContains Duplicate II.java)
+185|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIntersection of two Linked Lists.java)
+186|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConfusing Number.java)
+187|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFixed Point.java)
+188|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTo Lower Case.java)
+189|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlipping an Image.java)
+190|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount Binary Substrings.java)
+191|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Subarray Sum I.java)
+192|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReshape the matrix.java)
+193|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Distance to a Character.java)
+194|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind Pivot Index.java)
+195|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd Strings.java)
+196|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Integer.java)
+197|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind the Town Judge.java)
+198|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotated Digits.java)
+199|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge Two Sorted Lists.java)
+200|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Linked List.java)
+201|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRepeated String Match.java)
+202|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubtree of Another Tree.java)
+203|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGroups of Special-Equivalent Strings.java)
+204|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Product of three numbers.java)
+205|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement Stack using Queues.java)
+206|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHeight Checker.java)
+207|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum.java)
+208|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCompare Strings by Frequency of the Smallest Character.java)
+209|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMost Common Word.java)
+210|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Tree Level Order Traversal II.java)
+211|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Word in Dictionary.java)
+212|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMin Stack.java)
+213|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImage Smoother.java)
+214|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Unsorted Continuous Subarray.java)
+215|[Missing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMissing Numbers.java)
+216|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove Duplicates From Sorted Lists.java)
+217|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath In Zigzag Labelled Binary Tree.java)
+218|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax Stack.java)
+219|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum Depth of a Binary Tree.java)
+220|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySplit a String in Balanced Strings.java)
+221|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLength of last word.java)
+222|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySecond Minimum Node in a binary tree.java)
+223|[Average of levels in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAverage of levels in a binary tree.java)
+224|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyEmployee Importance.java)
+225|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum  Absolute Difference in BST.java)
+226|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlood Fill.java)
+227|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistribute Candies to People.java)
+228|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRansom Note.java)
+229|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Word Abbrevation.java)
+230|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyStudent Attendance Record I.java)
+231|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum Moves to Equal an Array Element.java)
+232|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBold Words in String.java)
+233|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easynim_game.java)
+234|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNext Greater Element.java)
+235|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNon-decreasing Array.java)
+236|[remove_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyremove_element.java)
+237|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyProjection Area of 3D Shapes.java)
+238|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome Number.java)
+239|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum of Even Numbers After Queries.java)
+240|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySquares of a Sorted Array.java)
+241|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyJudge Route Cycle.java)
+242|[intersection_of_two_arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyintersection_of_two_arrays.java)
+243|[move_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easymove_zeroes.java)
+244|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotate String.java)
+245|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Gap.java)
+246|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPerfect Number.java)
+247|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHouse Robber.java)
+248|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximize Distance to Closest Person.java)
+249|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPower of four.java)
+250|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Uncommon Subsequence.java)
+251|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique Morse Code Words.java)
+252|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnivalued Binary Tree.java)
+253|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPlus One.java)
+254|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd Binary.java)
+255|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse String.java)
+256|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMiddle of the linked list.java)
+257|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyK Closest Points to Origin.java)
+258|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistribute Candies.java)
+259|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPositions of Large Groups.java)
+260|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary Tree Postorder Traversal.java)
+261|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFibonacci Numbers.java)
+262|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove Vowels from a String.java)
+263|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGoat Latin.java)
+264|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyClimbing Stairs.java)
+265|[Best time to buy & sell a stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBest time to buy & sell a stock.java)
+266|[Invert a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyInvert a binary tree.java)
+267|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Harmonious Subsequence.java)
+268|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome Linked List.java)
+269|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement strStr.java)
+270|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyK-diff Pairs in an Array.java)
+271|[Range Sum Query_Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRange Sum Query_Immutable.java)
+272|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert Sorted Array To Binary Search Tree.java)
+273|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of segments in a String.java)
+274|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount Substrings with Only One Distinct Letter.java)
+275|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Palindrome.java)
+276|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Tree Tilt.java)
+277|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Perfect Square.java)
+278|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum_index_sum_of_two_lists.java)
+279|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPaint Fence.java)
+280|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Common Prefix.java)
+281|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArray Partition I.java)
diff --git a/Hard/Hard.md b/Hard/Hard.md
new file mode 100644
index 00000000..c612b7b3
--- /dev/null
+++ b/Hard/Hard.md
@@ -0,0 +1,56 @@
+# Hard LeetCode-Java-Solutions 
+S.no | Coding Problem 
+--- | --- 
+1|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMerge K Sorted Lists.java)
+2|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSerialize and Deserialize a Binary Tree.java)
+3|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardPalindrome Pairs.java)
+4|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBinary Tree PostOrder Traversal.java)
+5|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLargest Rectangle in Histogram.java)
+6|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardTrapping Rain Water.java)
+7|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardParallel Courses.java)
+8|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLFU Cache.java)
+9|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardUnique Paths III.java)
+10|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInteger to English Words.java)
+11|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardNumber of Valid Subarrays.java)
+12|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardCandy.java)
+13|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardOdd Even Jump.java)
+14|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest Consecutive Sequence.java)
+15|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSubstring with Concatenation of All Words.java)
+16|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMedian of Two Sorted Arrays.java)
+17|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest Substring with At Most K Distinct Characters.java)
+18|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardClosest Binary Search Tree Values II.java)
+19|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardEdit Distance.java)
+20|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest Palindrome Product.java)
+21|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardK Empty Slots.java)
+22|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardCut Off Trees for Golf Event.java)
+23|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardWord Break II.java)
+24|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLRU Cache.java)
+25|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardParsing A Boolean Expression.java)
+26|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMaximum Frequency Stack.java)
+27|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardN-Queens.java)
+28|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSliding Window Maximum.java)
+29|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardOptimal Account Balancing.java)
+30|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardDivide Array Into Increasing Sequences.java)
+31|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSerialize and Deserialize N-ary Tree.java)
+32|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardWord Search II.java)
+33|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInsert Delete GetRandom O(1) - Duplicates Allowed.java)
+34|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardRecover a Tree From Preorder Traversal.java)
+35|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardText Justification.java)
+36|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFind Median From Data Stream.java)
+37|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardNumber of Submatrices That Sum to Target.java)
+38|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFirst Missing Positive.java)
+39|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMinimum Window Substring.java)
+40|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardStream of Characters.java)
+41|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardPrefix and Suffix Search.java)
+42|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest Substring with At Most Two Distinct Characters.java)
+43|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFind Minimum in Rotated Sorted Array II.java)
+44|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSliding Window Median.java)
+45|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBasic Calculator.java)
+46|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBinary Tree Maximum Path Sum.java)
+47|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInterleaving String.java)
+48|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardValid Number.java)
+49|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardRobot Room Cleaner.java)
+50|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardEmployee Free Time.java)
+51|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardDesign Search Autocomplete System.java)
+52|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBasic Calculator III.java)
+53|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest Increasing Path in a Matrix.java)
diff --git a/Medium/Medium.md b/Medium/Medium.md
new file mode 100644
index 00000000..6cea41be
--- /dev/null
+++ b/Medium/Medium.md
@@ -0,0 +1,333 @@
+# Medium LeetCode-Java-Solutions 
+S.no | Coding Problem 
+--- | --- 
+1|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange Sum Query 2D-Immutable.java)
+2|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination Sum III.java)
+3|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDivide Two Integers.java)
+4|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUgly Number II.java)
+5|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSet Matrix Zeroes.java)
+6|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContainer With Most Water.java)
+7|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSpiral Matrix.java)
+8|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRabbits in Forest.java)
+9|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Tree Vertical Order Traversal.java)
+10|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBasic Calculator II.java)
+11|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCorporate Flight Bookings.java)
+12|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCustom Sort String.java)
+13|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum Moves to Equal Array Elements II.java)
+14|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate List.java)
+15|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten Nested List Iterator.java)
+16|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum Number of Arrows to Burst Balloons.java)
+17|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount Complete Tree Nodes.java)
+18|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch in Rotated Sorted Array.java)
+19|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray Product Less Than K.java)
+20|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique Binary Search Trees.java)
+21|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShuffle an Array.java)
+22|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutation in String.java)
+23|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten a Multilevel Doubly Linked List.java)
+24|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch in Rotated Sorted Array II.java)
+25|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPour Water.java)
+26|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind Leaves of Binary Tree.java)
+27|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMajority Element II.java)
+28|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCourse Schedule II.java)
+29|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign Circular Queue.java)
+30|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBattleships in a board.java)
+31|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext Greater Element III.java)
+32|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked List Components.java)
+33|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMultiply Strings.java)
+34|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConvert Binary Search Tree to Sorted Doubly Linked List.java)
+35|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd One Row to Tree.java)
+36|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Tree Pruning.java)
+37|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord Break.java)
+38|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInterval List Intersections.java)
+39|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPow.java)
+40|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDaily Temperatures.java)
+41|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumImplement Rand10() Using Rand7().java)
+42|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPalindromic Substrings.java)
+43|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse Substrings Between Each Pair of Parentheses.java)
+44|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign File System.java)
+45|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLowest Common Ancestor of Deepest Leaves.java)
+46|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGrumpy Bookstore Owner.java)
+47|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove Duplicates From Sorted Array II.java)
+48|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValidate IP Address.java)
+49|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBoats to Save People.java)
+50|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTernary Expression Parser.java)
+51|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind Peak Element.java)
+52|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign Tic-Tac-Toe.java)
+53|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKeys and Rooms.java)
+54|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCounting Bits.java)
+55|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSplit Linked List into Parts.java)
+56|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber of Connected Components in an Undirected Graph.java)
+57|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTask Scheduler.java)
+58|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOnline Election.java)
+59|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Width Ramp.java)
+60|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTime Based Key-Value Store.java)
+61|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSum Root to Leaf Numbers.java)
+62|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth Largest Element in an Array.java)
+63|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBitwise AND of Numbers Range.java)
+64|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Tree Longest Consecutive Sequence.java)
+65|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLargest BST Subtree.java)
+66|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPopulating Next Right Pointers in Each Node II.java)
+67|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOnline Stock Span.java)
+68|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination Sum II.java)
+69|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert Into a Cyclic Sorted List.java)
+70|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReconstruct Itinerary.java)
+71|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPartition Labels.java)
+72|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDistribute Coins in Binary Tree.java)
+73|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest Palindromic Substring.java)
+74|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSimplify Path.java)
+75|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumZigzag Iterator.java)
+76|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax Chunks To Make Sorted.java)
+77|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIs Subsequence.java)
+78|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse Linked List II.java)
+79|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumComplex Number Multiplication.java)
+80|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Binary Tree.java)
+81|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMeeting Rooms II.java)
+82|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFraction to Recurring Decimal.java)
+83|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd and Search Word - Data structure design.java)
+84|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSuper Ugly Number.java)
+85|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEscape The Ghosts.java)
+86|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax Increase to Keep City Skyline.java)
+87|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum Path Sum.java)
+88|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValid Tic-Tac-Toe State.java)
+89|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShortest Completing Word.java)
+90|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium01 Matrix.java)
+91|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAs Far from Land as Possible.java)
+92|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber of Matching Subsequence.java)
+93|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCar Pooling.java)
+94|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGenerate Parentheses.java)
+95|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumExclusive Time of Functions.java)
+96|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort Characters By Frequency.java)
+97|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax Consecutives Ones II.java)
+98|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber of Islands.java)
+99|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse Words in a String II.java)
+100|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Tree Upside Down.java)
+101|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount Univalue Subtrees.java)
+102|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSplit BST.java)
+103|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll Possible Full Binary Trees.java)
+104|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConvert Sorted List to Binary Search Tree.java)
+105|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord Search.java)
+106|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd Two Numbers II.java)
+107|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort List.java)
+108|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGray Code.java)
+109|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate Function.java)
+110|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBulb Switcher.java)
+111|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumImplement Trie (Prefix Tree).java)
+112|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContains Duplicate III.java)
+113|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCopy List with Random Pointer.java)
+114|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign Hit Counter.java)
+115|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Tree Inorder Traversal.java)
+116|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Product Subarray.java)
+117|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPrison Cells After N Days.java)
+118|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEvaluate Reverse Polish Notation.java)
+119|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumH-Index.java)
+120|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMini Parser.java)
+121|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLine Reflection.java)
+122|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked List Cycle II.java)
+123|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum Size Subarray Sum.java)
+124|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext Greater Element II.java)
+125|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecode String.java)
+126|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique Paths II.java)
+127|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShifting Letters.java)
+128|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray Sum Equals K.java)
+129|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGraph Valid Tree.java)
+130|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten Binary Tree to Linked List.java)
+131|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTop K Frequent Elements.java)
+132|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind First and Last Position of Element in Sorted Array.java)
+133|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBroken Calculator.java)
+134|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign Twitter.java)
+135|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNested List Weight Sum II.java)
+136|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutations II.java)
+137|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort An Array.java)
+138|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConstruct Quad Tree.java)
+139|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGame of Life.java)
+140|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove Nth Node From End of List.java)
+141|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRandom Pick Index.java)
+142|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMy Calendar II.java)
+143|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch for a range.java)
+144|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Tree Right Side View.java)
+145|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest Substring Without Repeating Characters.java)
+146|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle Number III.java)
+147|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCandy Crush.java)
+148|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWeb Crawler.java)
+149|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLonely Pixel I.java)
+150|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReorganize String.java)
+151|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsertion Sort List.java)
+152|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPeeking Iterator.java)
+153|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReorder List.java)
+154|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique Paths.java)
+155|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReconstruct Original Digits from English.java)
+156|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWalls and Gates.java)
+157|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTotal Hamming Distance.java)
+158|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRectangle Area.java)
+159|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Search Tree to Greater Sum Tree.java)
+160|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest Absolute File Path.java)
+161|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle Element in a Sorted Array.java)
+162|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Search Tree Iterator.java)
+163|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind K Closest Elements.java)
+164|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate Image.java)
+165|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext Permutation.java)
+166|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign Phone Directory.java)
+167|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumJump Game.java)
+168|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumH-Index II.java)
+169|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray Sums Divisible by K.java)
+170|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKill Process.java)
+171|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBoundary of Binary Tree.java)
+172|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCourse Schedule.java)
+173|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert Delete GetRandom O(1).java)
+174|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCoin Change 2.java)
+175|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind Duplicate Subtrees.java)
+176|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLetter Tiles Possibilities.java)
+177|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPalindrome Partitioning.java)
+178|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest Palindromic Subsequence.java)
+179|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumExpressive Words.java)
+180|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked List Random Node.java)
+181|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind Minimum in Rotated Sorted Array.java)
+182|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum Closest.java)
+183|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutations.java)
+184|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext Greater Node In Linked List.java)
+185|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMap Sum Pairs.java)
+186|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum Genetic Mutation.java)
+187|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Binary Tree II.java)
+188|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete Operation for Two Strings.java)
+189|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInorder Successor in BST.java)
+190|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArray Nesting.java)
+191|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOutput Contest Matches.java)
+192|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSerialize and Deserialize BST.java)
+193|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind the duplicate number.java)
+194|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle Number II.java)
+195|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumStatistics from a Large Sample.java)
+196|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAccounts Merge.java)
+197|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse Words in a String.java)
+198|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind Duplicate File in System.java)
+199|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete Node in a BST.java)
+200|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIs Graph Bipartite.java)
+201|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinesweeper.java)
+202|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove K Digits.java)
+203|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext Closest Time.java)
+204|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSelf Dividing Numbers.java)
+205|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReplace Words.java)
+206|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest Increasing Subsequence.java)
+207|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind Right Interval.java)
+208|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNon Overlapping Intervals.java)
+209|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange Addition.java)
+210|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum Smaller.java)
+211|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShortest Way to Form String.java)
+212|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMissing Element in Sorted Array.java)
+213|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsufficient Nodes in Root to Leaf Paths.java)
+214|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Width of Binary Tree.java)
+215|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumProduct of Array Except self.java)
+216|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort Colors.java)
+217|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArithmetic Slices.java)
+218|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber of Dice Rolls With Target Sum.java)
+219|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPerfect Squares.java)
+220|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch a 2D Matrix.java)
+221|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSatisfisbility of Equality Equations.java)
+222|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Length of Pair Chain.java)
+223|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumQueue Reconstruction By Height.java)
+224|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBulls and Cows.java)
+225|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique Word Abbrevation.java)
+226|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange Sum Query - Mutable.java)
+227|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete Nodes And Return Forest.java)
+228|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium4Sum.java)
+229|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMissing Ranges.java)
+230|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSentence Similarity II.java)
+231|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEvaluate Division.java)
+232|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind K Pairs with Smallest Sums.java)
+233|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPartition List.java)
+234|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEncode and Decode Strings.java)
+235|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecrease Elements To Make Array Zigzag.java)
+236|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Level Sum of a Binary Tree.java)
+237|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll Nodes Distance K in Binary Tree.java)
+238|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign Circular Deque.java)
+239|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign Log Storage System.java)
+240|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecode Ways.java)
+241|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort Transformed Array.java)
+242|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWiggle Sort.java)
+243|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPath Sum II.java)
+244|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubsets.java)
+245|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIncreasing Subsequences.java)
+246|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber of Distinct Islands.java)
+247|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd Two Numbers.java)
+248|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFruit Into Baskets.java)
+249|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLowest Common Ancestor of a Binary Tree.java)
+250|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumComplete Binary Tree Insertor.java)
+251|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumClone Graph.java)
+252|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Tree Preorder Traversal.java)
+253|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRandom Pick With Weight.java)
+254|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVertical Order Traversal Of Binary Tree.java)
+255|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove Duplicates from Sorted List II.java)
+256|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch in a Sorted Array of Unknown Size.java)
+257|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRectangle Overlap.java)
+258|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAnalyze User Website Visit Pattern.java)
+259|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination Sum.java)
+260|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSolve the Equation.java)
+261|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumThe Earliest Moment When Everyone Become Friends.java)
+262|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVerify Preorder Serialization of a Binary Tree.java)
+263|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOptimal Division.java)
+264|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumScore of Parentheses.java)
+265|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMerge Intervals.java)
+266|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth Smallest Element in a BST.java)
+267|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCoin Change.java)
+268|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind the Celebrity.java)
+269|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArray Circular Loop.java)
+270|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSnapshot Array.java)
+271|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTop K Frequent Words.java)
+272|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAsteroid Collision.java)
+273|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEncode and Decode TinyURL.java)
+274|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert into a Binary Search Tree.java)
+275|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord Ladder.java)
+276|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInorder Successor in BST II.java)
+277|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind and Replace Pattern.java)
+278|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber of Longest Increasing Subsequence.java)
+279|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove Comments.java)
+280|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPancake Sorting.java)
+281|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Size Subarray Sum Equals k.java)
+282|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum.java)
+283|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValid Triangle Number.java)
+284|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth Smallest Element in a Sorted Matrix.java)
+285|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumString to Integer(atoi).java)
+286|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll Paths From Source to Target.java)
+287|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary Tree Longest Consecutive Sequence II.java)
+288|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFriend Circles.java)
+289|[Swap Nodes in Pair](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSwap Nodes in Pair.java)
+290|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPlus One Linked List.java)
+291|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTeemo Attacking.java)
+292|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCompare Version Numbers.java)
+293|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSmallest String Starting From Leaf.java)
+294|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount Numbers With Unique Digits.java)
+295|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUncrossed Lines.java)
+296|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVowel Spellchecker.java)
+297|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContiguous Array.java)
+298|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest Well-Performing Interval.java)
+299|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind Bottom Left Tree Value.java)
+300|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumScore After Flipping Matrix.java)
+301|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium4 Sum II.java)
+302|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMost Frequent Subtree Sum.java)
+303|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombinations.java)
+304|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRLE Iterator.java)
+305|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSpiral Matrix II.java)
+306|[Find Largest Value in Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind Largest Value in Tree Row.java)
+307|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum Time Difference.java)
+308|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind all Duplicates in an Array.java)
+309|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDiagonal Traverse.java)
+310|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPrint Binary Tree.java)
+311|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMasking Personal Information.java)
+312|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSummary Ranges.java)
+313|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLetter Combinations of a Phone Number.java)
+314|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOdd Even Linked Lists.java)
+315|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind K-Length Substrings With No Repeated Characters.java)
+316|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumZigZag Conversion.java)
+317|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWater & Jug Problem.java)
+318|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind and Replace in String.java)
+319|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConstruct Binary Tree from Inorder and Postorder Traversal.java)
+320|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten 2D Vector.java)
+321|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumHand of Straights.java)
+322|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum Average Subtree.java)
+323|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRepeated DNA Sequences.java)
+324|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInteger To Roman.java)
+325|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMy Calendar I.java)
+326|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest Line of Consecutive One in Matrix.java)
+327|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGroup Shifted Strings.java)
+328|[Reverse Nodes in k-group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse Nodes in k-group.java)
+329|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOne Edit Distance.java)
+330|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd Bold Tag in String.java)
diff --git a/README.md b/README.md
index 9aeb16b7..595967e8 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,9 @@
-# LeetCode-Java-Solutions
-Repository to store solutions to various problems in Leetcode practice and weekly contests
+# Leetcode-Java-Solutions 
+
+## Solutions to Leetcode problems in Java
+Category | Count
+--- | ---
+Easy | 282
+Medium | 331
+Hard | 54
 
-![image](https://cdn-images-1.medium.com/max/1360/1*5qdPLs4x9TuabvQJwu7iuA.png)
diff --git a/script.py b/script.py
new file mode 100755
index 00000000..47e8ae75
--- /dev/null
+++ b/script.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+import os
+from os import listdir, getcwd
+from os.path import isfile, join
+
+
+current_dir = getcwd()
+
+# Clean up
+current_files = os.listdir(current_dir)
+for item in current_files:
+    if item.endswith(".md"):
+        os.remove(os.path.join(current_dir, item))
+
+tree_path = "https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/"
+levels = ["Easy", "Medium", "Hard"]
+for level in levels:
+    onlyfiles = [f for f in listdir(current_dir + "/" + level)]
+    f= open(level + ".md","w+")
+    f.write("# " + level + " LeetCode-Java-Solutions \n")
+    f.write("S.no | Coding Problem \n")
+    f.write("--- | --- \n")
+    count = 1
+    for file_name in onlyfiles:
+        only_name = file_name[:file_name.find('.')]
+        f.write(str(count) + "|" + '[{}]({})\n'.format(only_name, (tree_path + level + file_name)))
+        count = count + 1
+    print(level + ": " + str(count))
+    f.close()

From 92544e2ec797fe0eea502c326774f90adffec746 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Nov 2019 14:44:14 -0800
Subject: [PATCH 0040/2175] Update and rename Easy.md to README.md

---
 Easy/{Easy.md => README.md} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename Easy/{Easy.md => README.md} (99%)

diff --git a/Easy/Easy.md b/Easy/README.md
similarity index 99%
rename from Easy/Easy.md
rename to Easy/README.md
index ff6c3a2e..71db9c78 100644
--- a/Easy/Easy.md
+++ b/Easy/README.md
@@ -1,7 +1,7 @@
 # Easy LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's Triangle.java)
+1|(Pascal's Triangle)[https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's Triangle.java]
 2|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMeeting Rooms.java)
 3|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Bits.java)
 4|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCousins in Binary Tree.java)

From 79153bf4c175a9774fe22701c3708bfc7055109a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Nov 2019 14:52:00 -0800
Subject: [PATCH 0041/2175] README cleanup and question index creation

---
 Easy/{Easy.md => README.md} | 524 ++++++++++++++++++------------------
 Hard/README.md              |  57 ++++
 Medium/README.md            | 334 +++++++++++++++++++++++
 README.md                   |   1 +
 script.py                   |  15 +-
 5 files changed, 663 insertions(+), 268 deletions(-)
 rename Easy/{Easy.md => README.md} (52%)
 create mode 100644 Hard/README.md
 create mode 100644 Medium/README.md

diff --git a/Easy/Easy.md b/Easy/README.md
similarity index 52%
rename from Easy/Easy.md
rename to Easy/README.md
index ff6c3a2e..34f372cb 100644
--- a/Easy/Easy.md
+++ b/Easy/README.md
@@ -1,284 +1,284 @@
 # Easy LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's Triangle.java)
-2|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMeeting Rooms.java)
-3|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Bits.java)
-4|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCousins in Binary Tree.java)
-5|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyKeyboard Row.java)
-6|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest Unique Number.java)
-7|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAssign Cookies.java)
-8|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Depth of N-ary Tree.java)
-9|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount and Say.java)
-10|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArranging Coins.java)
-11|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Number of Balloons.java)
-12|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConstruct the rectangle.java)
-13|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMagic Squares In Grid.java)
-14|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMatrix Cells in Distance Order.java)
-15|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy1-bit and 2-bit Characters.java)
-16|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind the difference.java)
-17|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFactorial Trailing Zeroes.java)
-18|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySentence Similarity.java)
-19|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest Number At Least Twice of Others.java)
-20|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax Area of Island.java)
-21|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Palindrome.java)
-22|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Word Distance III.java)
-23|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyString Compression.java)
+1|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's%20Triangle.java)
+2|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMeeting%20Rooms.java)
+3|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20Bits.java)
+4|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCousins%20in%20Binary%20Tree.java)
+5|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyKeyboard%20Row.java)
+6|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest%20Unique%20Number.java)
+7|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAssign%20Cookies.java)
+8|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Depth%20of%20N-ary%20Tree.java)
+9|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount%20and%20Say.java)
+10|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArranging%20Coins.java)
+11|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Number%20of%20Balloons.java)
+12|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConstruct%20the%20rectangle.java)
+13|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMagic%20Squares%20In%20Grid.java)
+14|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMatrix%20Cells%20in%20Distance%20Order.java)
+15|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy1-bit%20and%202-bit%20Characters.java)
+16|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20the%20difference.java)
+17|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFactorial%20Trailing%20Zeroes.java)
+18|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySentence%20Similarity.java)
+19|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest%20Number%20At%20Least%20Twice%20of%20Others.java)
+20|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax%20Area%20of%20Island.java)
+21|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Palindrome.java)
+22|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Word%20Distance%20III.java)
+23|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyString%20Compression.java)
 24|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easytrailing_zeroes.java)
-25|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGreatest Common Divisor of Strings.java)
-26|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum IV - Input is a BST.java)
-27|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLinked List Cycle.java)
-28|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDelete node in a linked list.java)
-29|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyExcel Sheet Column Number.java)
-30|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPairs of Songs With Total Durations Divisible by 60.java)
-31|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove Linked List Elements.java)
-32|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySingle-Row Keyboard.java)
-33|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMissing Number In Arithmetic Progression.java)
-34|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum of left leaves.java)
-35|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign Compressed String Iterator.java)
-36|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Boomerang.java)
-37|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlip Game.java)
-38|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAvailable Captures for Rook.java)
-39|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyStrobogrammatic Number.java)
-40|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd to Array-Form of Integer.java)
-41|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse words in a String III.java)
-42|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLowest Common Ancestor of a Binary Search Tree.java)
-43|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind Mode in Binary Search Tree.java)
-44|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of 1 bits.java)
-45|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIncreasing Order Search Tree.java)
-46|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyOccurrences After Bigram.java)
-47|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign HashSet.java)
-48|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyExcel Sheet Column Title.java)
-49|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind All Numbers Disappeared in an Array.java)
+25|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGreatest%20Common%20Divisor%20of%20Strings.java)
+26|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
+27|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLinked%20List%20Cycle.java)
+28|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDelete%20node%20in%20a%20linked%20list.java)
+29|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyExcel%20Sheet%20Column%20Number.java)
+30|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
+31|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove%20Linked%20List%20Elements.java)
+32|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySingle-Row%20Keyboard.java)
+33|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMissing%20Number%20In%20Arithmetic%20Progression.java)
+34|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum%20of%20left%20leaves.java)
+35|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign%20Compressed%20String%20Iterator.java)
+36|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Boomerang.java)
+37|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlip%20Game.java)
+38|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAvailable%20Captures%20for%20Rook.java)
+39|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyStrobogrammatic%20Number.java)
+40|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd%20to%20Array-Form%20of%20Integer.java)
+41|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20words%20in%20a%20String%20III.java)
+42|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
+43|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20Mode%20in%20Binary%20Search%20Tree.java)
+44|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%201%20bits.java)
+45|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIncreasing%20Order%20Search%20Tree.java)
+46|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyOccurrences%20After%20Bigram.java)
+47|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign%20HashSet.java)
+48|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyExcel%20Sheet%20Column%20Title.java)
+49|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
 50|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easysum_of_two_integers.java)
-51|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLogger Rate Limiter.java)
-52|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath Sum.java)
-53|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySearch Insert Position.java)
-54|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySearch in a Binary Search Tree.java)
-55|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of Equivalent Domino Pairs.java)
-56|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyJewels and Stones.java)
-57|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique Email Addresses.java)
-58|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRoman to Integer.java)
-59|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount Primes.java)
-60|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyComplement of Base 10 Integer.java)
-61|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Subarray.java)
+51|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLogger%20Rate%20Limiter.java)
+52|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath%20Sum.java)
+53|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySearch%20Insert%20Position.java)
+54|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySearch%20in%20a%20Binary%20Search%20Tree.java)
+55|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20Equivalent%20Domino%20Pairs.java)
+56|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyJewels%20and%20Stones.java)
+57|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique%20Email%20Addresses.java)
+58|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRoman%20to%20Integer.java)
+59|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount%20Primes.java)
+60|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyComplement%20of%20Base%2010%20Integer.java)
+61|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Subarray.java)
 62|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easycontains_duplicates.java)
-63|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of Boomerangs.java)
-64|[Valid Parantheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Parantheses.java)
+63|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20Boomerangs.java)
+64|[Valid Parantheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Parantheses.java)
 65|[remove_duplicates_sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyremove_duplicates_sorted.java)
-66|[Sum of square numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum of square numbers.java)
+66|[Sum of square numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum%20of%20square%20numbers.java)
 67|[add_digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyadd_digit.java)
-68|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLetter Case Permutation.java)
-69|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTranspose Matrix.java)
-70|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Number with Alternating Bits.java)
-71|[Power of three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPower of three.java)
-72|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove All Adjacent Duplicates In String.java)
-73|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Continuous Increasing Subsequence.java)
-74|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome Permutation.java)
-75|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Word Sequence.java)
-76|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPowerful Integers.java)
-77|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIsomorphic Strings.java)
-78|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUncommon Words from Two Sentences.java)
-79|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign HashMap.java)
-80|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBackspace String Compare.java)
-81|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax Consecutive Ones.java)
-82|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHappy Number.java)
-83|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath Sum III.java)
-84|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Word Distance.java)
-85|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Prefix Divisible By 5.java)
-86|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLeaf-Similar Trees.java)
-87|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNested List Weight Sum.java)
-88|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGuess Number Higher or Lower.java)
-89|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMonotonic Array.java)
+68|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLetter%20Case%20Permutation.java)
+69|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTranspose%20Matrix.java)
+70|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Number%20with%20Alternating%20Bits.java)
+71|[Power of three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPower%20of%20three.java)
+72|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove%20All%20Adjacent%20Duplicates%20In%20String.java)
+73|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Continuous%20Increasing%20Subsequence.java)
+74|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome%20Permutation.java)
+75|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Word%20Sequence.java)
+76|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPowerful%20Integers.java)
+77|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIsomorphic%20Strings.java)
+78|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUncommon%20Words%20from%20Two%20Sentences.java)
+79|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign%20HashMap.java)
+80|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBackspace%20String%20Compare.java)
+81|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax%20Consecutive%20Ones.java)
+82|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHappy%20Number.java)
+83|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath%20Sum%20III.java)
+84|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Word%20Distance.java)
+85|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Prefix%20Divisible%20By%205.java)
+86|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLeaf-Similar%20Trees.java)
+87|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNested%20List%20Weight%20Sum.java)
+88|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGuess%20Number%20Higher%20or%20Lower.java)
+89|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMonotonic%20Array.java)
 90|[ugly_number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyugly_number.java)
-91|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of Days in a Month.java)
-92|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum III - Data Structure Design.java)
-93|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIsland Perimeter.java)
+91|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20Days%20in%20a%20Month.java)
+92|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum%20III%20-%20Data%20Structure%20Design.java)
+93|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIsland%20Perimeter.java)
 94|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySqrtX.java)
-95|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFair Candy Swap.java)
+95|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFair%20Candy%20Swap.java)
 96|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHeaters.java)
-97|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTrim a Binary Search Tree.java)
-98|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFirst Bad Version.java)
-99|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySingle Number.java)
-100|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyClosest Binary Search Tree Value.java)
-101|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Word Distance II.java)
-102|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySymmetric Tree.java)
-103|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum Absolute Difference.java)
-104|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Palindrome II.java)
-105|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRead N characters Given Read4.java)
-106|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary Tree Level Order Traversal.java)
-107|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse String II.java)
-108|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDegree of an array.java)
-109|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind All Anagrams in a String.java)
-110|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubmission Detail.java)
-111|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Tree Paths.java)
-112|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotate Array.java)
-113|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDay of the Year.java)
-114|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySet Mismatch.java)
+97|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTrim%20a%20Binary%20Search%20Tree.java)
+98|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFirst%20Bad%20Version.java)
+99|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySingle%20Number.java)
+100|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyClosest%20Binary%20Search%20Tree%20Value.java)
+101|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Word%20Distance%20II.java)
+102|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySymmetric%20Tree.java)
+103|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20Absolute%20Difference.java)
+104|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Palindrome%20II.java)
+105|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRead%20N%20characters%20Given%20Read4.java)
+106|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary%20Tree%20Level%20Order%20Traversal.java)
+107|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20String%20II.java)
+108|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDegree%20of%20an%20array.java)
+109|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20All%20Anagrams%20in%20a%20String.java)
+110|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubmission%20Detail.java)
+111|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Tree%20Paths.java)
+112|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotate%20Array.java)
+113|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDay%20of%20the%20Year.java)
+114|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySet%20Mismatch.java)
 115|[majority_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easymajority_element.java)
-116|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber Complement.java)
+116|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20Complement.java)
 117|[power_of_2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easypower_of_2.java)
-118|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCan Place Flowers.java)
-119|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest Perimeter Triangle.java)
-120|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRelative ranks.java)
-121|[Convert BST to greater tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert BST to greater tree.java)
+118|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCan%20Place%20Flowers.java)
+119|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest%20Perimeter%20Triangle.java)
+120|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRelative%20ranks.java)
+121|[Convert BST to greater tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert%20BST%20to%20greater%20tree.java)
 122|[valid_anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyvalid_anagrams.java)
-123|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLicense Key Formatting.java)
-124|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyVerifying an Alien Dictionary.java)
-125|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDiameter of Binary Tree.java)
+123|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLicense%20Key%20Formatting.java)
+124|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyVerifying%20an%20Alien%20Dictionary.java)
+125|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDiameter%20of%20Binary%20Tree.java)
 126|[first_unique_character_in_a_string](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyfirst_unique_character_in_a_string.java)
-127|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMoving Average from Data Stream.java)
-128|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDiet Plan Performance.java)
-129|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubdomain Visit Count.java)
-130|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDuplicate Zeros.java)
-131|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySame Tree.java)
+127|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMoving%20Average%20from%20Data%20Stream.java)
+128|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDiet%20Plan%20Performance.java)
+129|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubdomain%20Visit%20Count.java)
+130|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDuplicate%20Zeros.java)
+131|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySame%20Tree.java)
 132|[FizzBuzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFizzBuzz.java)
-133|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBuddy Strings.java)
-134|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyThird Maximum Number.java)
-135|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's Triangle II.java)
-136|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyWord Pattern.java)
-137|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHamming Distance.java)
-138|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum Distance Between BST Nodes.java)
-139|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind Words That Can Be Formed by Characters.java)
-140|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDefanging an IP Address.java)
-141|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Vowels of a String.java)
-142|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBalanced Binary Tree.java)
-143|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHow Many Apples Can You Put into the Basket.java)
-144|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyString Without AAA or BBB.java)
-145|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement Queue using Stacks.java)
-146|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBaseball Game.java)
+133|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBuddy%20Strings.java)
+134|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyThird%20Maximum%20Number.java)
+135|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's%20Triangle%20II.java)
+136|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyWord%20Pattern.java)
+137|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHamming%20Distance.java)
+138|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20Distance%20Between%20BST%20Nodes.java)
+139|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
+140|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDefanging%20an%20IP%20Address.java)
+141|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20Vowels%20of%20a%20String.java)
+142|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBalanced%20Binary%20Tree.java)
+143|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHow%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
+144|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyString%20Without%20AAA%20or%20BBB.java)
+145|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement%20Queue%20using%20Stacks.java)
+146|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBaseball%20Game.java)
 147|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyrange_addition_II.java)
-148|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign Linked List.java)
-149|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert a number to hexadecimal.java)
-150|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyToeplitz Matrix.java)
-151|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-th Tribonacci Number.java)
-152|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyKth Largest Element in a Stream.java)
-153|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary Tree Preorder Traversal.java)
-154|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPaint House.java)
-155|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPeak Index in a Mountain Array.java)
-156|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Search.java)
-157|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum Less Than K.java)
-158|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum depth of Binary tree.java)
-159|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotting Oranges.java)
-160|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArmstrong Number.java)
-161|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBest time to buy & sell a stock II.java)
-162|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBase 7.java)
-163|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Univalue Path.java)
-164|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRepeated Substring Pattern.java)
-165|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Distance in Arrays.java)
-166|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRelative Sort Array.java)
-167|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique Number of Occurrences.java)
-168|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLast Stone Weight.java)
-169|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest Triangle Area.java)
-170|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMin Cost Climbing Stairs.java)
-171|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of Lines To Write String.java)
-172|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDetect Capital.java)
-173|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum II.java)
-174|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistance Between Bus Stops.java)
-175|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum of Digits in the Minimum Number.java)
-176|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCheck If a Number Is Majority Element in a Sorted Array.java)
-177|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge two binary trees.java)
-178|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConstruct String from Binary Tree.java)
-179|[Merge Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge Sorted Arrays.java)
-180|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-Repeated Element in Size 2N Array.java)
-181|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIntersection of two arrays II.java)
-182|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo City Scheduling.java)
-183|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHigh Five.java)
-184|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyContains Duplicate II.java)
-185|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIntersection of two Linked Lists.java)
-186|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConfusing Number.java)
-187|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFixed Point.java)
-188|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTo Lower Case.java)
-189|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlipping an Image.java)
-190|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount Binary Substrings.java)
-191|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Subarray Sum I.java)
-192|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReshape the matrix.java)
-193|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Distance to a Character.java)
-194|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind Pivot Index.java)
-195|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd Strings.java)
-196|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Integer.java)
-197|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind the Town Judge.java)
-198|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotated Digits.java)
-199|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge Two Sorted Lists.java)
-200|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse Linked List.java)
-201|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRepeated String Match.java)
-202|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubtree of Another Tree.java)
-203|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGroups of Special-Equivalent Strings.java)
-204|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum Product of three numbers.java)
-205|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement Stack using Queues.java)
-206|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHeight Checker.java)
-207|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo Sum.java)
-208|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCompare Strings by Frequency of the Smallest Character.java)
-209|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMost Common Word.java)
-210|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Tree Level Order Traversal II.java)
-211|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Word in Dictionary.java)
-212|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMin Stack.java)
-213|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImage Smoother.java)
-214|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest Unsorted Continuous Subarray.java)
-215|[Missing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMissing Numbers.java)
-216|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove Duplicates From Sorted Lists.java)
-217|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath In Zigzag Labelled Binary Tree.java)
-218|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax Stack.java)
-219|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum Depth of a Binary Tree.java)
-220|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySplit a String in Balanced Strings.java)
-221|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLength of last word.java)
-222|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySecond Minimum Node in a binary tree.java)
-223|[Average of levels in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAverage of levels in a binary tree.java)
-224|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyEmployee Importance.java)
-225|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum  Absolute Difference in BST.java)
-226|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlood Fill.java)
-227|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistribute Candies to People.java)
-228|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRansom Note.java)
-229|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Word Abbrevation.java)
-230|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyStudent Attendance Record I.java)
-231|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum Moves to Equal an Array Element.java)
-232|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBold Words in String.java)
+148|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign%20Linked%20List.java)
+149|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert%20a%20number%20to%20hexadecimal.java)
+150|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyToeplitz%20Matrix.java)
+151|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-th%20Tribonacci%20Number.java)
+152|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyKth%20Largest%20Element%20in%20a%20Stream.java)
+153|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary%20Tree%20Preorder%20Traversal.java)
+154|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPaint%20House.java)
+155|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPeak%20Index%20in%20a%20Mountain%20Array.java)
+156|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Search.java)
+157|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum%20Less%20Than%20K.java)
+158|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20depth%20of%20Binary%20tree.java)
+159|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotting%20Oranges.java)
+160|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArmstrong%20Number.java)
+161|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBest%20time%20to%20buy%20&%20sell%20a%20stock%20II.java)
+162|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBase%207.java)
+163|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Univalue%20Path.java)
+164|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRepeated%20Substring%20Pattern.java)
+165|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Distance%20in%20Arrays.java)
+166|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRelative%20Sort%20Array.java)
+167|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique%20Number%20of%20Occurrences.java)
+168|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLast%20Stone%20Weight.java)
+169|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest%20Triangle%20Area.java)
+170|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMin%20Cost%20Climbing%20Stairs.java)
+171|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20Lines%20To%20Write%20String.java)
+172|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDetect%20Capital.java)
+173|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum%20II.java)
+174|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistance%20Between%20Bus%20Stops.java)
+175|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum%20of%20Digits%20in%20the%20Minimum%20Number.java)
+176|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCheck%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
+177|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge%20two%20binary%20trees.java)
+178|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConstruct%20String%20from%20Binary%20Tree.java)
+179|[Merge Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge%20Sorted%20Arrays.java)
+180|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-Repeated%20Element%20in%20Size%202N%20Array.java)
+181|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIntersection%20of%20two%20arrays%20II.java)
+182|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20City%20Scheduling.java)
+183|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHigh%20Five.java)
+184|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyContains%20Duplicate%20II.java)
+185|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIntersection%20of%20two%20Linked%20Lists.java)
+186|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConfusing%20Number.java)
+187|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFixed%20Point.java)
+188|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTo%20Lower%20Case.java)
+189|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlipping%20an%20Image.java)
+190|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount%20Binary%20Substrings.java)
+191|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Subarray%20Sum%20I.java)
+192|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReshape%20the%20matrix.java)
+193|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Distance%20to%20a%20Character.java)
+194|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20Pivot%20Index.java)
+195|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd%20Strings.java)
+196|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20Integer.java)
+197|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20the%20Town%20Judge.java)
+198|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotated%20Digits.java)
+199|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge%20Two%20Sorted%20Lists.java)
+200|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20Linked%20List.java)
+201|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRepeated%20String%20Match.java)
+202|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubtree%20of%20Another%20Tree.java)
+203|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGroups%20of%20Special-Equivalent%20Strings.java)
+204|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Product%20of%20three%20numbers.java)
+205|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement%20Stack%20using%20Queues.java)
+206|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHeight%20Checker.java)
+207|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum.java)
+208|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCompare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
+209|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMost%20Common%20Word.java)
+210|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Tree%20Level%20Order%20Traversal%20II.java)
+211|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Word%20in%20Dictionary.java)
+212|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMin%20Stack.java)
+213|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImage%20Smoother.java)
+214|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Unsorted%20Continuous%20Subarray.java)
+215|[Missing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMissing%20Numbers.java)
+216|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove%20Duplicates%20From%20Sorted%20Lists.java)
+217|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
+218|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax%20Stack.java)
+219|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20Depth%20of%20a%20Binary%20Tree.java)
+220|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySplit%20a%20String%20in%20Balanced%20Strings.java)
+221|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLength%20of%20last%20word.java)
+222|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySecond%20Minimum%20Node%20in%20a%20binary%20tree.java)
+223|[Average of levels in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAverage%20of%20levels%20in%20a%20binary%20tree.java)
+224|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyEmployee%20Importance.java)
+225|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20%20Absolute%20Difference%20in%20BST.java)
+226|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlood%20Fill.java)
+227|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistribute%20Candies%20to%20People.java)
+228|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRansom%20Note.java)
+229|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Word%20Abbrevation.java)
+230|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyStudent%20Attendance%20Record%20I.java)
+231|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
+232|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBold%20Words%20in%20String.java)
 233|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easynim_game.java)
-234|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNext Greater Element.java)
-235|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNon-decreasing Array.java)
+234|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNext%20Greater%20Element.java)
+235|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNon-decreasing%20Array.java)
 236|[remove_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyremove_element.java)
-237|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyProjection Area of 3D Shapes.java)
-238|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome Number.java)
-239|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum of Even Numbers After Queries.java)
-240|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySquares of a Sorted Array.java)
-241|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyJudge Route Cycle.java)
+237|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyProjection%20Area%20of%203D%20Shapes.java)
+238|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome%20Number.java)
+239|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum%20of%20Even%20Numbers%20After%20Queries.java)
+240|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySquares%20of%20a%20Sorted%20Array.java)
+241|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyJudge%20Route%20Cycle.java)
 242|[intersection_of_two_arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyintersection_of_two_arrays.java)
 243|[move_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easymove_zeroes.java)
-244|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotate String.java)
-245|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Gap.java)
-246|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPerfect Number.java)
-247|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHouse Robber.java)
-248|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximize Distance to Closest Person.java)
-249|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPower of four.java)
-250|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Uncommon Subsequence.java)
-251|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique Morse Code Words.java)
-252|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnivalued Binary Tree.java)
-253|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPlus One.java)
-254|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd Binary.java)
-255|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse String.java)
-256|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMiddle of the linked list.java)
-257|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyK Closest Points to Origin.java)
-258|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistribute Candies.java)
-259|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPositions of Large Groups.java)
-260|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary Tree Postorder Traversal.java)
-261|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFibonacci Numbers.java)
-262|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove Vowels from a String.java)
-263|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGoat Latin.java)
-264|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyClimbing Stairs.java)
-265|[Best time to buy & sell a stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBest time to buy & sell a stock.java)
-266|[Invert a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyInvert a binary tree.java)
-267|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Harmonious Subsequence.java)
-268|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome Linked List.java)
-269|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement strStr.java)
-270|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyK-diff Pairs in an Array.java)
-271|[Range Sum Query_Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRange Sum Query_Immutable.java)
-272|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert Sorted Array To Binary Search Tree.java)
-273|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber of segments in a String.java)
-274|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount Substrings with Only One Distinct Letter.java)
-275|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Palindrome.java)
-276|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary Tree Tilt.java)
-277|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid Perfect Square.java)
+244|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotate%20String.java)
+245|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Gap.java)
+246|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPerfect%20Number.java)
+247|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHouse%20Robber.java)
+248|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximize%20Distance%20to%20Closest%20Person.java)
+249|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPower%20of%20four.java)
+250|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Uncommon%20Subsequence.java)
+251|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique%20Morse%20Code%20Words.java)
+252|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnivalued%20Binary%20Tree.java)
+253|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPlus%20One.java)
+254|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd%20Binary.java)
+255|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20String.java)
+256|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMiddle%20of%20the%20linked%20list.java)
+257|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyK%20Closest%20Points%20to%20Origin.java)
+258|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistribute%20Candies.java)
+259|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPositions%20of%20Large%20Groups.java)
+260|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary%20Tree%20Postorder%20Traversal.java)
+261|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFibonacci%20Numbers.java)
+262|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove%20Vowels%20from%20a%20String.java)
+263|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGoat%20Latin.java)
+264|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyClimbing%20Stairs.java)
+265|[Best time to buy & sell a stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBest%20time%20to%20buy%20&%20sell%20a%20stock.java)
+266|[Invert a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyInvert%20a%20binary%20tree.java)
+267|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Harmonious%20Subsequence.java)
+268|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome%20Linked%20List.java)
+269|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement%20strStr.java)
+270|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyK-diff%20Pairs%20in%20an%20Array.java)
+271|[Range Sum Query_Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRange%20Sum%20Query_Immutable.java)
+272|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
+273|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20segments%20in%20a%20String.java)
+274|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
+275|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Palindrome.java)
+276|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Tree%20Tilt.java)
+277|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Perfect%20Square.java)
 278|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum_index_sum_of_two_lists.java)
-279|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPaint Fence.java)
-280|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest Common Prefix.java)
-281|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArray Partition I.java)
+279|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPaint%20Fence.java)
+280|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Common%20Prefix.java)
+281|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArray%20Partition%20I.java)
diff --git a/Hard/README.md b/Hard/README.md
new file mode 100644
index 00000000..bb2d8efa
--- /dev/null
+++ b/Hard/README.md
@@ -0,0 +1,57 @@
+# Hard LeetCode-Java-Solutions 
+S.no | Coding Problem 
+--- | --- 
+1|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMerge%20K%20Sorted%20Lists.java)
+2|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSerialize%20and%20Deserialize%20a%20Binary%20Tree.java)
+3|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardPalindrome%20Pairs.java)
+4|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBinary%20Tree%20PostOrder%20Traversal.java)
+5|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLargest%20Rectangle%20in%20Histogram.java)
+6|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardTrapping%20Rain%20Water.java)
+7|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardParallel%20Courses.java)
+8|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLFU%20Cache.java)
+9|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardUnique%20Paths%20III.java)
+10|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInteger%20to%20English%20Words.java)
+11|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardNumber%20of%20Valid%20Subarrays.java)
+12|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardCandy.java)
+13|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardOdd%20Even%20Jump.java)
+14|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Consecutive%20Sequence.java)
+15|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSubstring%20with%20Concatenation%20of%20All%20Words.java)
+16|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMedian%20of%20Two%20Sorted%20Arrays.java)
+17|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardHard.md)
+18|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
+19|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardClosest%20Binary%20Search%20Tree%20Values%20II.java)
+20|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardEdit%20Distance.java)
+21|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Palindrome%20Product.java)
+22|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardK%20Empty%20Slots.java)
+23|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardCut%20Off%20Trees%20for%20Golf%20Event.java)
+24|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardWord%20Break%20II.java)
+25|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLRU%20Cache.java)
+26|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardParsing%20A%20Boolean%20Expression.java)
+27|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMaximum%20Frequency%20Stack.java)
+28|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardN-Queens.java)
+29|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSliding%20Window%20Maximum.java)
+30|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardOptimal%20Account%20Balancing.java)
+31|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardDivide%20Array%20Into%20Increasing%20Sequences.java)
+32|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSerialize%20and%20Deserialize%20N-ary%20Tree.java)
+33|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardWord%20Search%20II.java)
+34|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInsert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
+35|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardRecover%20a%20Tree%20From%20Preorder%20Traversal.java)
+36|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardText%20Justification.java)
+37|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFind%20Median%20From%20Data%20Stream.java)
+38|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardNumber%20of%20Submatrices%20That%20Sum%20to%20Target.java)
+39|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFirst%20Missing%20Positive.java)
+40|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMinimum%20Window%20Substring.java)
+41|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardStream%20of%20Characters.java)
+42|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardPrefix%20and%20Suffix%20Search.java)
+43|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+44|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFind%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
+45|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSliding%20Window%20Median.java)
+46|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBasic%20Calculator.java)
+47|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBinary%20Tree%20Maximum%20Path%20Sum.java)
+48|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInterleaving%20String.java)
+49|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardValid%20Number.java)
+50|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardRobot%20Room%20Cleaner.java)
+51|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardEmployee%20Free%20Time.java)
+52|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardDesign%20Search%20Autocomplete%20System.java)
+53|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBasic%20Calculator%20III.java)
+54|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Increasing%20Path%20in%20a%20Matrix.java)
diff --git a/Medium/README.md b/Medium/README.md
new file mode 100644
index 00000000..f9bada7e
--- /dev/null
+++ b/Medium/README.md
@@ -0,0 +1,334 @@
+# Medium LeetCode-Java-Solutions 
+S.no | Coding Problem 
+--- | --- 
+1|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange%20Sum%20Query%202D-Immutable.java)
+2|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination%20Sum%20III.java)
+3|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDivide%20Two%20Integers.java)
+4|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUgly%20Number%20II.java)
+5|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSet%20Matrix%20Zeroes.java)
+6|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContainer%20With%20Most%20Water.java)
+7|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSpiral%20Matrix.java)
+8|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRabbits%20in%20Forest.java)
+9|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Vertical%20Order%20Traversal.java)
+10|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBasic%20Calculator%20II.java)
+11|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCorporate%20Flight%20Bookings.java)
+12|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCustom%20Sort%20String.java)
+13|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
+14|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate%20List.java)
+15|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten%20Nested%20List%20Iterator.java)
+16|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
+17|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount%20Complete%20Tree%20Nodes.java)
+18|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20in%20Rotated%20Sorted%20Array.java)
+19|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray%20Product%20Less%20Than%20K.java)
+20|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique%20Binary%20Search%20Trees.java)
+21|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShuffle%20an%20Array.java)
+22|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutation%20in%20String.java)
+23|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
+24|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20in%20Rotated%20Sorted%20Array%20II.java)
+25|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPour%20Water.java)
+26|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Leaves%20of%20Binary%20Tree.java)
+27|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMajority%20Element%20II.java)
+28|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCourse%20Schedule%20II.java)
+29|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Circular%20Queue.java)
+30|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBattleships%20in%20a%20board.java)
+31|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Greater%20Element%20III.java)
+32|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked%20List%20Components.java)
+33|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMultiply%20Strings.java)
+34|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConvert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
+35|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20One%20Row%20to%20Tree.java)
+36|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Pruning.java)
+37|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord%20Break.java)
+38|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInterval%20List%20Intersections.java)
+39|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPow.java)
+40|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDaily%20Temperatures.java)
+41|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumImplement%20Rand10()%20Using%20Rand7().java)
+42|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPalindromic%20Substrings.java)
+43|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
+44|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20File%20System.java)
+45|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
+46|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGrumpy%20Bookstore%20Owner.java)
+47|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20Duplicates%20From%20Sorted%20Array%20II.java)
+48|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValidate%20IP%20Address.java)
+49|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBoats%20to%20Save%20People.java)
+50|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTernary%20Expression%20Parser.java)
+51|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Peak%20Element.java)
+52|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Tic-Tac-Toe.java)
+53|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKeys%20and%20Rooms.java)
+54|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCounting%20Bits.java)
+55|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSplit%20Linked%20List%20into%20Parts.java)
+56|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
+57|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTask%20Scheduler.java)
+58|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOnline%20Election.java)
+59|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Width%20Ramp.java)
+60|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTime%20Based%20Key-Value%20Store.java)
+61|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSum%20Root%20to%20Leaf%20Numbers.java)
+62|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth%20Largest%20Element%20in%20an%20Array.java)
+63|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBitwise%20AND%20of%20Numbers%20Range.java)
+64|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Longest%20Consecutive%20Sequence.java)
+65|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLargest%20BST%20Subtree.java)
+66|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPopulating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
+67|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOnline%20Stock%20Span.java)
+68|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination%20Sum%20II.java)
+69|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert%20Into%20a%20Cyclic%20Sorted%20List.java)
+70|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReconstruct%20Itinerary.java)
+71|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPartition%20Labels.java)
+72|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDistribute%20Coins%20in%20Binary%20Tree.java)
+73|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Palindromic%20Substring.java)
+74|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSimplify%20Path.java)
+75|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumZigzag%20Iterator.java)
+76|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax%20Chunks%20To%20Make%20Sorted.java)
+77|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIs%20Subsequence.java)
+78|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Linked%20List%20II.java)
+79|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumComplex%20Number%20Multiplication.java)
+80|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Binary%20Tree.java)
+81|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMeeting%20Rooms%20II.java)
+82|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFraction%20to%20Recurring%20Decimal.java)
+83|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20and%20Search%20Word%20-%20Data%20structure%20design.java)
+84|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSuper%20Ugly%20Number.java)
+85|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEscape%20The%20Ghosts.java)
+86|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax%20Increase%20to%20Keep%20City%20Skyline.java)
+87|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Path%20Sum.java)
+88|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValid%20Tic-Tac-Toe%20State.java)
+89|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShortest%20Completing%20Word.java)
+90|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium01%20Matrix.java)
+91|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAs%20Far%20from%20Land%20as%20Possible.java)
+92|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Matching%20Subsequence.java)
+93|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCar%20Pooling.java)
+94|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGenerate%20Parentheses.java)
+95|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumExclusive%20Time%20of%20Functions.java)
+96|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20Characters%20By%20Frequency.java)
+97|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax%20Consecutives%20Ones%20II.java)
+98|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Islands.java)
+99|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Words%20in%20a%20String%20II.java)
+100|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Upside%20Down.java)
+101|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount%20Univalue%20Subtrees.java)
+102|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSplit%20BST.java)
+103|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll%20Possible%20Full%20Binary%20Trees.java)
+104|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConvert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
+105|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord%20Search.java)
+106|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20Two%20Numbers%20II.java)
+107|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20List.java)
+108|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGray%20Code.java)
+109|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate%20Function.java)
+110|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBulb%20Switcher.java)
+111|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumImplement%20Trie%20(Prefix%20Tree).java)
+112|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContains%20Duplicate%20III.java)
+113|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCopy%20List%20with%20Random%20Pointer.java)
+114|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Hit%20Counter.java)
+115|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMedium.md)
+116|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Inorder%20Traversal.java)
+117|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Product%20Subarray.java)
+118|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPrison%20Cells%20After%20N%20Days.java)
+119|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEvaluate%20Reverse%20Polish%20Notation.java)
+120|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumH-Index.java)
+121|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMini%20Parser.java)
+122|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLine%20Reflection.java)
+123|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked%20List%20Cycle%20II.java)
+124|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Size%20Subarray%20Sum.java)
+125|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Greater%20Element%20II.java)
+126|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecode%20String.java)
+127|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique%20Paths%20II.java)
+128|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShifting%20Letters.java)
+129|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray%20Sum%20Equals%20K.java)
+130|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGraph%20Valid%20Tree.java)
+131|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten%20Binary%20Tree%20to%20Linked%20List.java)
+132|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTop%20K%20Frequent%20Elements.java)
+133|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
+134|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBroken%20Calculator.java)
+135|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Twitter.java)
+136|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNested%20List%20Weight%20Sum%20II.java)
+137|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutations%20II.java)
+138|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20An%20Array.java)
+139|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConstruct%20Quad%20Tree.java)
+140|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGame%20of%20Life.java)
+141|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20Nth%20Node%20From%20End%20of%20List.java)
+142|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRandom%20Pick%20Index.java)
+143|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMy%20Calendar%20II.java)
+144|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20for%20a%20range.java)
+145|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Right%20Side%20View.java)
+146|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Substring%20Without%20Repeating%20Characters.java)
+147|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle%20Number%20III.java)
+148|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCandy%20Crush.java)
+149|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWeb%20Crawler.java)
+150|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLonely%20Pixel%20I.java)
+151|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReorganize%20String.java)
+152|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsertion%20Sort%20List.java)
+153|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPeeking%20Iterator.java)
+154|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReorder%20List.java)
+155|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique%20Paths.java)
+156|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReconstruct%20Original%20Digits%20from%20English.java)
+157|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWalls%20and%20Gates.java)
+158|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTotal%20Hamming%20Distance.java)
+159|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRectangle%20Area.java)
+160|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
+161|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Absolute%20File%20Path.java)
+162|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle%20Element%20in%20a%20Sorted%20Array.java)
+163|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Search%20Tree%20Iterator.java)
+164|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20K%20Closest%20Elements.java)
+165|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate%20Image.java)
+166|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Permutation.java)
+167|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Phone%20Directory.java)
+168|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumJump%20Game.java)
+169|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumH-Index%20II.java)
+170|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray%20Sums%20Divisible%20by%20K.java)
+171|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKill%20Process.java)
+172|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBoundary%20of%20Binary%20Tree.java)
+173|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCourse%20Schedule.java)
+174|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert%20Delete%20GetRandom%20O(1).java)
+175|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCoin%20Change%202.java)
+176|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Duplicate%20Subtrees.java)
+177|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLetter%20Tiles%20Possibilities.java)
+178|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPalindrome%20Partitioning.java)
+179|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Palindromic%20Subsequence.java)
+180|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumExpressive%20Words.java)
+181|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked%20List%20Random%20Node.java)
+182|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Minimum%20in%20Rotated%20Sorted%20Array.java)
+183|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum%20Closest.java)
+184|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutations.java)
+185|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Greater%20Node%20In%20Linked%20List.java)
+186|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMap%20Sum%20Pairs.java)
+187|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Genetic%20Mutation.java)
+188|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Binary%20Tree%20II.java)
+189|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete%20Operation%20for%20Two%20Strings.java)
+190|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInorder%20Successor%20in%20BST.java)
+191|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArray%20Nesting.java)
+192|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOutput%20Contest%20Matches.java)
+193|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSerialize%20and%20Deserialize%20BST.java)
+194|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20the%20duplicate%20number.java)
+195|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle%20Number%20II.java)
+196|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumStatistics%20from%20a%20Large%20Sample.java)
+197|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAccounts%20Merge.java)
+198|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Words%20in%20a%20String.java)
+199|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Duplicate%20File%20in%20System.java)
+200|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete%20Node%20in%20a%20BST.java)
+201|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIs%20Graph%20Bipartite.java)
+202|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinesweeper.java)
+203|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20K%20Digits.java)
+204|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Closest%20Time.java)
+205|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSelf%20Dividing%20Numbers.java)
+206|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReplace%20Words.java)
+207|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Increasing%20Subsequence.java)
+208|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Right%20Interval.java)
+209|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNon%20Overlapping%20Intervals.java)
+210|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange%20Addition.java)
+211|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum%20Smaller.java)
+212|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShortest%20Way%20to%20Form%20String.java)
+213|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMissing%20Element%20in%20Sorted%20Array.java)
+214|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
+215|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Width%20of%20Binary%20Tree.java)
+216|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumProduct%20of%20Array%20Except%20self.java)
+217|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20Colors.java)
+218|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArithmetic%20Slices.java)
+219|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
+220|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPerfect%20Squares.java)
+221|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20a%202D%20Matrix.java)
+222|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSatisfisbility%20of%20Equality%20Equations.java)
+223|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Length%20of%20Pair%20Chain.java)
+224|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumQueue%20Reconstruction%20By%20Height.java)
+225|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBulls%20and%20Cows.java)
+226|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique%20Word%20Abbrevation.java)
+227|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange%20Sum%20Query%20-%20Mutable.java)
+228|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete%20Nodes%20And%20Return%20Forest.java)
+229|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium4Sum.java)
+230|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMissing%20Ranges.java)
+231|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSentence%20Similarity%20II.java)
+232|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEvaluate%20Division.java)
+233|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20K%20Pairs%20with%20Smallest%20Sums.java)
+234|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPartition%20List.java)
+235|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEncode%20and%20Decode%20Strings.java)
+236|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecrease%20Elements%20To%20Make%20Array%20Zigzag.java)
+237|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
+238|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
+239|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Circular%20Deque.java)
+240|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Log%20Storage%20System.java)
+241|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecode%20Ways.java)
+242|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20Transformed%20Array.java)
+243|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWiggle%20Sort.java)
+244|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPath%20Sum%20II.java)
+245|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubsets.java)
+246|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIncreasing%20Subsequences.java)
+247|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Distinct%20Islands.java)
+248|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20Two%20Numbers.java)
+249|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFruit%20Into%20Baskets.java)
+250|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
+251|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumComplete%20Binary%20Tree%20Insertor.java)
+252|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumClone%20Graph.java)
+253|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Preorder%20Traversal.java)
+254|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRandom%20Pick%20With%20Weight.java)
+255|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVertical%20Order%20Traversal%20Of%20Binary%20Tree.java)
+256|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20Duplicates%20from%20Sorted%20List%20II.java)
+257|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
+258|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRectangle%20Overlap.java)
+259|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAnalyze%20User%20Website%20Visit%20Pattern.java)
+260|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination%20Sum.java)
+261|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSolve%20the%20Equation.java)
+262|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumThe%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
+263|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVerify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
+264|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOptimal%20Division.java)
+265|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumScore%20of%20Parentheses.java)
+266|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMerge%20Intervals.java)
+267|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth%20Smallest%20Element%20in%20a%20BST.java)
+268|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCoin%20Change.java)
+269|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20the%20Celebrity.java)
+270|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArray%20Circular%20Loop.java)
+271|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSnapshot%20Array.java)
+272|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTop%20K%20Frequent%20Words.java)
+273|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAsteroid%20Collision.java)
+274|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEncode%20and%20Decode%20TinyURL.java)
+275|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert%20into%20a%20Binary%20Search%20Tree.java)
+276|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord%20Ladder.java)
+277|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInorder%20Successor%20in%20BST%20II.java)
+278|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20and%20Replace%20Pattern.java)
+279|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Longest%20Increasing%20Subsequence.java)
+280|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20Comments.java)
+281|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPancake%20Sorting.java)
+282|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Size%20Subarray%20Sum%20Equals%20k.java)
+283|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum.java)
+284|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValid%20Triangle%20Number.java)
+285|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
+286|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumString%20to%20Integer(atoi).java)
+287|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll%20Paths%20From%20Source%20to%20Target.java)
+288|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
+289|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFriend%20Circles.java)
+290|[Swap Nodes in Pair](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSwap%20Nodes%20in%20Pair.java)
+291|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPlus%20One%20Linked%20List.java)
+292|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTeemo%20Attacking.java)
+293|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCompare%20Version%20Numbers.java)
+294|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSmallest%20String%20Starting%20From%20Leaf.java)
+295|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount%20Numbers%20With%20Unique%20Digits.java)
+296|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUncrossed%20Lines.java)
+297|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVowel%20Spellchecker.java)
+298|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContiguous%20Array.java)
+299|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Well-Performing%20Interval.java)
+300|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Bottom%20Left%20Tree%20Value.java)
+301|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumScore%20After%20Flipping%20Matrix.java)
+302|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium4%20Sum%20II.java)
+303|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMost%20Frequent%20Subtree%20Sum.java)
+304|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombinations.java)
+305|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRLE%20Iterator.java)
+306|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSpiral%20Matrix%20II.java)
+307|[Find Largest Value in Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Largest%20Value%20in%20Tree%20Row.java)
+308|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Time%20Difference.java)
+309|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20all%20Duplicates%20in%20an%20Array.java)
+310|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDiagonal%20Traverse.java)
+311|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPrint%20Binary%20Tree.java)
+312|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMasking%20Personal%20Information.java)
+313|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSummary%20Ranges.java)
+314|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLetter%20Combinations%20of%20a%20Phone%20Number.java)
+315|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOdd%20Even%20Linked%20Lists.java)
+316|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
+317|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumZigZag%20Conversion.java)
+318|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWater%20&%20Jug%20Problem.java)
+319|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20and%20Replace%20in%20String.java)
+320|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConstruct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
+321|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten%202D%20Vector.java)
+322|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumHand%20of%20Straights.java)
+323|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Average%20Subtree.java)
+324|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRepeated%20DNA%20Sequences.java)
+325|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInteger%20To%20Roman.java)
+326|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMy%20Calendar%20I.java)
+327|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
+328|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGroup%20Shifted%20Strings.java)
+329|[Reverse Nodes in k-group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Nodes%20in%20k-group.java)
+330|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOne%20Edit%20Distance.java)
+331|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20Bold%20Tag%20in%20String.java)
diff --git a/README.md b/README.md
index 595967e8..95f863a5 100644
--- a/README.md
+++ b/README.md
@@ -7,3 +7,4 @@ Easy | 282
 Medium | 331
 Hard | 54
 
+
diff --git a/script.py b/script.py
index 47e8ae75..7af387c6 100755
--- a/script.py
+++ b/script.py
@@ -7,23 +7,26 @@
 current_dir = getcwd()
 
 # Clean up
-current_files = os.listdir(current_dir)
-for item in current_files:
-    if item.endswith(".md"):
-        os.remove(os.path.join(current_dir, item))
+# current_files = os.listdir(current_dir)
+# for item in current_files:
+#     if item.endswith(".md"):
+#         os.remove(os.path.join(current_dir, item))
 
 tree_path = "https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/"
 levels = ["Easy", "Medium", "Hard"]
 for level in levels:
+    if os.path.exists(current_dir + "/" + level + "/README.md"):
+        os.remove(current_dir + "/" + level + "/README.md")
     onlyfiles = [f for f in listdir(current_dir + "/" + level)]
-    f= open(level + ".md","w+")
+    f= open(current_dir + "/" + level + "/README.md","w+")
     f.write("# " + level + " LeetCode-Java-Solutions \n")
     f.write("S.no | Coding Problem \n")
     f.write("--- | --- \n")
     count = 1
     for file_name in onlyfiles:
         only_name = file_name[:file_name.find('.')]
-        f.write(str(count) + "|" + '[{}]({})\n'.format(only_name, (tree_path + level + file_name)))
+        updated_file_name = file_name.replace(' ', '%20')
+        f.write(str(count) + "|" + '[{}]({})\n'.format(only_name, (tree_path + level + updated_file_name)))
         count = count + 1
     print(level + ": " + str(count))
     f.close()

From b09cd7097baad06e493155e4666368a4ea5ec2f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Nov 2019 14:54:00 -0800
Subject: [PATCH 0042/2175] Fixed a bug in script

---
 Easy/README.md   | 562 ++++++++++++++++++++--------------------
 Hard/README.md   | 108 ++++----
 Medium/README.md | 662 +++++++++++++++++++++++------------------------
 script.py        |   2 +-
 4 files changed, 667 insertions(+), 667 deletions(-)

diff --git a/Easy/README.md b/Easy/README.md
index 34f372cb..b9713c84 100644
--- a/Easy/README.md
+++ b/Easy/README.md
@@ -1,284 +1,284 @@
 # Easy LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's%20Triangle.java)
-2|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMeeting%20Rooms.java)
-3|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20Bits.java)
-4|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCousins%20in%20Binary%20Tree.java)
-5|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyKeyboard%20Row.java)
-6|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest%20Unique%20Number.java)
-7|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAssign%20Cookies.java)
-8|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Depth%20of%20N-ary%20Tree.java)
-9|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount%20and%20Say.java)
-10|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArranging%20Coins.java)
-11|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Number%20of%20Balloons.java)
-12|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConstruct%20the%20rectangle.java)
-13|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMagic%20Squares%20In%20Grid.java)
-14|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMatrix%20Cells%20in%20Distance%20Order.java)
-15|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy1-bit%20and%202-bit%20Characters.java)
-16|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20the%20difference.java)
-17|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFactorial%20Trailing%20Zeroes.java)
-18|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySentence%20Similarity.java)
-19|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest%20Number%20At%20Least%20Twice%20of%20Others.java)
-20|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax%20Area%20of%20Island.java)
-21|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Palindrome.java)
-22|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Word%20Distance%20III.java)
-23|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyString%20Compression.java)
-24|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easytrailing_zeroes.java)
-25|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGreatest%20Common%20Divisor%20of%20Strings.java)
-26|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
-27|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLinked%20List%20Cycle.java)
-28|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDelete%20node%20in%20a%20linked%20list.java)
-29|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyExcel%20Sheet%20Column%20Number.java)
-30|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
-31|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove%20Linked%20List%20Elements.java)
-32|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySingle-Row%20Keyboard.java)
-33|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMissing%20Number%20In%20Arithmetic%20Progression.java)
-34|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum%20of%20left%20leaves.java)
-35|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign%20Compressed%20String%20Iterator.java)
-36|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Boomerang.java)
-37|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlip%20Game.java)
-38|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAvailable%20Captures%20for%20Rook.java)
-39|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyStrobogrammatic%20Number.java)
-40|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd%20to%20Array-Form%20of%20Integer.java)
-41|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20words%20in%20a%20String%20III.java)
-42|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
-43|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20Mode%20in%20Binary%20Search%20Tree.java)
-44|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%201%20bits.java)
-45|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIncreasing%20Order%20Search%20Tree.java)
-46|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyOccurrences%20After%20Bigram.java)
-47|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign%20HashSet.java)
-48|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyExcel%20Sheet%20Column%20Title.java)
-49|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
-50|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easysum_of_two_integers.java)
-51|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLogger%20Rate%20Limiter.java)
-52|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath%20Sum.java)
-53|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySearch%20Insert%20Position.java)
-54|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySearch%20in%20a%20Binary%20Search%20Tree.java)
-55|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20Equivalent%20Domino%20Pairs.java)
-56|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyJewels%20and%20Stones.java)
-57|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique%20Email%20Addresses.java)
-58|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRoman%20to%20Integer.java)
-59|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount%20Primes.java)
-60|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyComplement%20of%20Base%2010%20Integer.java)
-61|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Subarray.java)
-62|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easycontains_duplicates.java)
-63|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20Boomerangs.java)
-64|[Valid Parantheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Parantheses.java)
-65|[remove_duplicates_sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyremove_duplicates_sorted.java)
-66|[Sum of square numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum%20of%20square%20numbers.java)
-67|[add_digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyadd_digit.java)
-68|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLetter%20Case%20Permutation.java)
-69|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTranspose%20Matrix.java)
-70|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Number%20with%20Alternating%20Bits.java)
-71|[Power of three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPower%20of%20three.java)
-72|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove%20All%20Adjacent%20Duplicates%20In%20String.java)
-73|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Continuous%20Increasing%20Subsequence.java)
-74|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome%20Permutation.java)
-75|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Word%20Sequence.java)
-76|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPowerful%20Integers.java)
-77|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIsomorphic%20Strings.java)
-78|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUncommon%20Words%20from%20Two%20Sentences.java)
-79|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign%20HashMap.java)
-80|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBackspace%20String%20Compare.java)
-81|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax%20Consecutive%20Ones.java)
-82|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHappy%20Number.java)
-83|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath%20Sum%20III.java)
-84|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Word%20Distance.java)
-85|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Prefix%20Divisible%20By%205.java)
-86|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLeaf-Similar%20Trees.java)
-87|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNested%20List%20Weight%20Sum.java)
-88|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGuess%20Number%20Higher%20or%20Lower.java)
-89|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMonotonic%20Array.java)
-90|[ugly_number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyugly_number.java)
-91|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20Days%20in%20a%20Month.java)
-92|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum%20III%20-%20Data%20Structure%20Design.java)
-93|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIsland%20Perimeter.java)
-94|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySqrtX.java)
-95|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFair%20Candy%20Swap.java)
-96|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHeaters.java)
-97|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTrim%20a%20Binary%20Search%20Tree.java)
-98|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFirst%20Bad%20Version.java)
-99|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySingle%20Number.java)
-100|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyClosest%20Binary%20Search%20Tree%20Value.java)
-101|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Word%20Distance%20II.java)
-102|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySymmetric%20Tree.java)
-103|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20Absolute%20Difference.java)
-104|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Palindrome%20II.java)
-105|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRead%20N%20characters%20Given%20Read4.java)
-106|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary%20Tree%20Level%20Order%20Traversal.java)
-107|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20String%20II.java)
-108|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDegree%20of%20an%20array.java)
-109|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20All%20Anagrams%20in%20a%20String.java)
-110|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubmission%20Detail.java)
-111|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Tree%20Paths.java)
-112|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotate%20Array.java)
-113|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDay%20of%20the%20Year.java)
-114|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySet%20Mismatch.java)
-115|[majority_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easymajority_element.java)
-116|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20Complement.java)
-117|[power_of_2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easypower_of_2.java)
-118|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCan%20Place%20Flowers.java)
-119|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest%20Perimeter%20Triangle.java)
-120|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRelative%20ranks.java)
-121|[Convert BST to greater tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert%20BST%20to%20greater%20tree.java)
-122|[valid_anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyvalid_anagrams.java)
-123|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLicense%20Key%20Formatting.java)
-124|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyVerifying%20an%20Alien%20Dictionary.java)
-125|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDiameter%20of%20Binary%20Tree.java)
-126|[first_unique_character_in_a_string](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyfirst_unique_character_in_a_string.java)
-127|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMoving%20Average%20from%20Data%20Stream.java)
-128|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDiet%20Plan%20Performance.java)
-129|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubdomain%20Visit%20Count.java)
-130|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDuplicate%20Zeros.java)
-131|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySame%20Tree.java)
-132|[FizzBuzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFizzBuzz.java)
-133|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBuddy%20Strings.java)
-134|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyThird%20Maximum%20Number.java)
-135|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPascal's%20Triangle%20II.java)
-136|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyWord%20Pattern.java)
-137|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHamming%20Distance.java)
-138|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20Distance%20Between%20BST%20Nodes.java)
-139|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
-140|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDefanging%20an%20IP%20Address.java)
-141|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20Vowels%20of%20a%20String.java)
-142|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBalanced%20Binary%20Tree.java)
-143|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHow%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
-144|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyString%20Without%20AAA%20or%20BBB.java)
-145|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement%20Queue%20using%20Stacks.java)
-146|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBaseball%20Game.java)
-147|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyrange_addition_II.java)
-148|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDesign%20Linked%20List.java)
-149|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert%20a%20number%20to%20hexadecimal.java)
-150|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyToeplitz%20Matrix.java)
-151|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-th%20Tribonacci%20Number.java)
-152|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyKth%20Largest%20Element%20in%20a%20Stream.java)
-153|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary%20Tree%20Preorder%20Traversal.java)
-154|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPaint%20House.java)
-155|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPeak%20Index%20in%20a%20Mountain%20Array.java)
-156|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Search.java)
-157|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum%20Less%20Than%20K.java)
-158|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20depth%20of%20Binary%20tree.java)
-159|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotting%20Oranges.java)
-160|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArmstrong%20Number.java)
-161|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBest%20time%20to%20buy%20&%20sell%20a%20stock%20II.java)
-162|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBase%207.java)
-163|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Univalue%20Path.java)
-164|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRepeated%20Substring%20Pattern.java)
-165|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Distance%20in%20Arrays.java)
-166|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRelative%20Sort%20Array.java)
-167|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique%20Number%20of%20Occurrences.java)
-168|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLast%20Stone%20Weight.java)
-169|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLargest%20Triangle%20Area.java)
-170|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMin%20Cost%20Climbing%20Stairs.java)
-171|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20Lines%20To%20Write%20String.java)
-172|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDetect%20Capital.java)
-173|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum%20II.java)
-174|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistance%20Between%20Bus%20Stops.java)
-175|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum%20of%20Digits%20in%20the%20Minimum%20Number.java)
-176|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCheck%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
-177|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge%20two%20binary%20trees.java)
-178|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConstruct%20String%20from%20Binary%20Tree.java)
-179|[Merge Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge%20Sorted%20Arrays.java)
-180|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-Repeated%20Element%20in%20Size%202N%20Array.java)
-181|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIntersection%20of%20two%20arrays%20II.java)
-182|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20City%20Scheduling.java)
-183|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHigh%20Five.java)
-184|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyContains%20Duplicate%20II.java)
-185|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyIntersection%20of%20two%20Linked%20Lists.java)
-186|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConfusing%20Number.java)
-187|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFixed%20Point.java)
-188|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTo%20Lower%20Case.java)
-189|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlipping%20an%20Image.java)
-190|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount%20Binary%20Substrings.java)
-191|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Subarray%20Sum%20I.java)
-192|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReshape%20the%20matrix.java)
-193|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Distance%20to%20a%20Character.java)
-194|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20Pivot%20Index.java)
-195|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd%20Strings.java)
-196|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20Integer.java)
-197|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFind%20the%20Town%20Judge.java)
-198|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotated%20Digits.java)
-199|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMerge%20Two%20Sorted%20Lists.java)
-200|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20Linked%20List.java)
-201|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRepeated%20String%20Match.java)
-202|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySubtree%20of%20Another%20Tree.java)
-203|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGroups%20of%20Special-Equivalent%20Strings.java)
-204|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximum%20Product%20of%20three%20numbers.java)
-205|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement%20Stack%20using%20Queues.java)
-206|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHeight%20Checker.java)
-207|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyTwo%20Sum.java)
-208|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCompare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
-209|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMost%20Common%20Word.java)
-210|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Tree%20Level%20Order%20Traversal%20II.java)
-211|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Word%20in%20Dictionary.java)
-212|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMin%20Stack.java)
-213|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImage%20Smoother.java)
-214|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyShortest%20Unsorted%20Continuous%20Subarray.java)
-215|[Missing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMissing%20Numbers.java)
-216|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove%20Duplicates%20From%20Sorted%20Lists.java)
-217|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPath%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
-218|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMax%20Stack.java)
-219|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20Depth%20of%20a%20Binary%20Tree.java)
-220|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySplit%20a%20String%20in%20Balanced%20Strings.java)
-221|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLength%20of%20last%20word.java)
-222|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySecond%20Minimum%20Node%20in%20a%20binary%20tree.java)
-223|[Average of levels in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAverage%20of%20levels%20in%20a%20binary%20tree.java)
-224|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyEmployee%20Importance.java)
-225|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20%20Absolute%20Difference%20in%20BST.java)
-226|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFlood%20Fill.java)
-227|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistribute%20Candies%20to%20People.java)
-228|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRansom%20Note.java)
-229|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Word%20Abbrevation.java)
-230|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyStudent%20Attendance%20Record%20I.java)
-231|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
-232|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBold%20Words%20in%20String.java)
-233|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easynim_game.java)
-234|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNext%20Greater%20Element.java)
-235|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNon-decreasing%20Array.java)
-236|[remove_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyremove_element.java)
-237|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyProjection%20Area%20of%203D%20Shapes.java)
-238|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome%20Number.java)
-239|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySum%20of%20Even%20Numbers%20After%20Queries.java)
-240|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasySquares%20of%20a%20Sorted%20Array.java)
-241|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyJudge%20Route%20Cycle.java)
-242|[intersection_of_two_arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easyintersection_of_two_arrays.java)
-243|[move_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easymove_zeroes.java)
-244|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRotate%20String.java)
-245|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Gap.java)
-246|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPerfect%20Number.java)
-247|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyHouse%20Robber.java)
-248|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMaximize%20Distance%20to%20Closest%20Person.java)
-249|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPower%20of%20four.java)
-250|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Uncommon%20Subsequence.java)
-251|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnique%20Morse%20Code%20Words.java)
-252|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyUnivalued%20Binary%20Tree.java)
-253|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPlus%20One.java)
-254|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyAdd%20Binary.java)
-255|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyReverse%20String.java)
-256|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMiddle%20of%20the%20linked%20list.java)
-257|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyK%20Closest%20Points%20to%20Origin.java)
-258|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyDistribute%20Candies.java)
-259|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPositions%20of%20Large%20Groups.java)
-260|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyN-ary%20Tree%20Postorder%20Traversal.java)
-261|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyFibonacci%20Numbers.java)
-262|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRemove%20Vowels%20from%20a%20String.java)
-263|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyGoat%20Latin.java)
-264|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyClimbing%20Stairs.java)
-265|[Best time to buy & sell a stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBest%20time%20to%20buy%20&%20sell%20a%20stock.java)
-266|[Invert a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyInvert%20a%20binary%20tree.java)
-267|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Harmonious%20Subsequence.java)
-268|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPalindrome%20Linked%20List.java)
-269|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyImplement%20strStr.java)
-270|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyK-diff%20Pairs%20in%20an%20Array.java)
-271|[Range Sum Query_Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyRange%20Sum%20Query_Immutable.java)
-272|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyConvert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
-273|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyNumber%20of%20segments%20in%20a%20String.java)
-274|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyCount%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
-275|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Palindrome.java)
-276|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyBinary%20Tree%20Tilt.java)
-277|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyValid%20Perfect%20Square.java)
-278|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyMinimum_index_sum_of_two_lists.java)
-279|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyPaint%20Fence.java)
-280|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyLongest%20Common%20Prefix.java)
-281|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/EasyArray%20Partition%20I.java)
+1|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
+2|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
+3|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
+4|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
+5|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
+6|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
+7|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
+8|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
+9|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20and%20Say.java)
+10|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
+11|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
+12|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
+13|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
+14|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
+15|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
+16|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
+17|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
+18|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
+19|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
+20|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Area%20of%20Island.java)
+21|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
+22|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance%20III.java)
+23|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Compression.java)
+24|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
+25|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
+26|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
+27|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
+28|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20node%20in%20a%20linked%20list.java)
+29|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
+30|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
+31|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
+32|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
+33|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
+34|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20left%20leaves.java)
+35|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
+36|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
+37|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
+38|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
+39|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
+40|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
+41|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
+42|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
+43|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
+44|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
+45|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
+46|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
+47|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
+48|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
+49|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
+50|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/sum_of_two_integers.java)
+51|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
+52|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
+53|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
+54|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
+55|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
+56|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
+57|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
+58|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
+59|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
+60|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
+61|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java)
+62|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/contains_duplicates.java)
+63|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
+64|[Valid Parantheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parantheses.java)
+65|[remove_duplicates_sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/remove_duplicates_sorted.java)
+66|[Sum of square numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20square%20numbers.java)
+67|[add_digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/add_digit.java)
+68|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
+69|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
+70|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
+71|[Power of three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20three.java)
+72|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
+73|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
+74|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
+75|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
+76|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
+77|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
+78|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
+79|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
+80|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
+81|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
+82|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
+83|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum%20III.java)
+84|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
+85|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
+86|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
+87|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
+88|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
+89|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
+90|[ugly_number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/ugly_number.java)
+91|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
+92|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
+93|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
+94|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
+95|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
+96|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
+97|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Trim%20a%20Binary%20Search%20Tree.java)
+98|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
+99|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
+100|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
+101|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance%20II.java)
+102|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
+103|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
+104|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
+105|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
+106|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Level%20Order%20Traversal.java)
+107|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
+108|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
+109|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Anagrams%20in%20a%20String.java)
+110|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
+111|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
+112|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20Array.java)
+113|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
+114|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
+115|[majority_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/majority_element.java)
+116|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
+117|[power_of_2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/power_of_2.java)
+118|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
+119|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
+120|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
+121|[Convert BST to greater tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20greater%20tree.java)
+122|[valid_anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/valid_anagrams.java)
+123|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
+124|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
+125|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
+126|[first_unique_character_in_a_string](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/first_unique_character_in_a_string.java)
+127|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
+128|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
+129|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subdomain%20Visit%20Count.java)
+130|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
+131|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
+132|[FizzBuzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/FizzBuzz.java)
+133|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
+134|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
+135|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
+136|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
+137|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
+138|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
+139|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
+140|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
+141|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
+142|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
+143|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
+144|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
+145|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
+146|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
+147|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
+148|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
+149|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
+150|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
+151|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
+152|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
+153|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
+154|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
+155|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
+156|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
+157|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
+158|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
+159|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotting%20Oranges.java)
+160|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
+161|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20time%20to%20buy%20&%20sell%20a%20stock%20II.java)
+162|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
+163|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
+164|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
+165|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
+166|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
+167|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
+168|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
+169|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
+170|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
+171|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
+172|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
+173|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20II.java)
+174|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
+175|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
+176|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
+177|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
+178|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
+179|[Merge Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Arrays.java)
+180|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
+181|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20arrays%20II.java)
+182|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20City%20Scheduling.java)
+183|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
+184|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
+185|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
+186|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
+187|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
+188|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
+189|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
+190|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
+191|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
+192|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
+193|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
+194|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
+195|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
+196|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Integer.java)
+197|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
+198|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotated%20Digits.java)
+199|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
+200|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
+201|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
+202|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
+203|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
+204|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20three%20numbers.java)
+205|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
+206|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
+207|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
+208|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
+209|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
+210|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
+211|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
+212|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Stack.java)
+213|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
+214|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Unsorted%20Continuous%20Subarray.java)
+215|[Missing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Numbers.java)
+216|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
+217|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
+218|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Stack.java)
+219|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
+220|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
+221|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
+222|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
+223|[Average of levels in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20levels%20in%20a%20binary%20tree.java)
+224|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
+225|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
+226|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
+227|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
+228|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
+229|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbrevation.java)
+230|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
+231|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
+232|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bold%20Words%20in%20String.java)
+233|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
+234|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
+235|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Non-decreasing%20Array.java)
+236|[remove_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/remove_element.java)
+237|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
+238|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
+239|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Even%20Numbers%20After%20Queries.java)
+240|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
+241|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
+242|[intersection_of_two_arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/intersection_of_two_arrays.java)
+243|[move_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/move_zeroes.java)
+244|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
+245|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
+246|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
+247|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/House%20Robber.java)
+248|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Distance%20to%20Closest%20Person.java)
+249|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20four.java)
+250|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
+251|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
+252|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
+253|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
+254|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
+255|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
+256|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
+257|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Closest%20Points%20to%20Origin.java)
+258|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
+259|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
+260|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
+261|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Numbers.java)
+262|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
+263|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
+264|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
+265|[Best time to buy & sell a stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20time%20to%20buy%20&%20sell%20a%20stock.java)
+266|[Invert a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20a%20binary%20tree.java)
+267|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
+268|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
+269|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
+270|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
+271|[Range Sum Query_Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query_Immutable.java)
+272|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
+273|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
+274|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
+275|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
+276|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
+277|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
+278|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
+279|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
+280|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
+281|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
diff --git a/Hard/README.md b/Hard/README.md
index bb2d8efa..3bf228e4 100644
--- a/Hard/README.md
+++ b/Hard/README.md
@@ -1,57 +1,57 @@
 # Hard LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMerge%20K%20Sorted%20Lists.java)
-2|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSerialize%20and%20Deserialize%20a%20Binary%20Tree.java)
-3|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardPalindrome%20Pairs.java)
-4|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBinary%20Tree%20PostOrder%20Traversal.java)
-5|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLargest%20Rectangle%20in%20Histogram.java)
-6|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardTrapping%20Rain%20Water.java)
-7|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardParallel%20Courses.java)
-8|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLFU%20Cache.java)
-9|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardUnique%20Paths%20III.java)
-10|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInteger%20to%20English%20Words.java)
-11|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardNumber%20of%20Valid%20Subarrays.java)
-12|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardCandy.java)
-13|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardOdd%20Even%20Jump.java)
-14|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Consecutive%20Sequence.java)
-15|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSubstring%20with%20Concatenation%20of%20All%20Words.java)
-16|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMedian%20of%20Two%20Sorted%20Arrays.java)
-17|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardHard.md)
-18|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
-19|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardClosest%20Binary%20Search%20Tree%20Values%20II.java)
-20|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardEdit%20Distance.java)
-21|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Palindrome%20Product.java)
-22|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardK%20Empty%20Slots.java)
-23|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardCut%20Off%20Trees%20for%20Golf%20Event.java)
-24|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardWord%20Break%20II.java)
-25|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLRU%20Cache.java)
-26|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardParsing%20A%20Boolean%20Expression.java)
-27|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMaximum%20Frequency%20Stack.java)
-28|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardN-Queens.java)
-29|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSliding%20Window%20Maximum.java)
-30|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardOptimal%20Account%20Balancing.java)
-31|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardDivide%20Array%20Into%20Increasing%20Sequences.java)
-32|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSerialize%20and%20Deserialize%20N-ary%20Tree.java)
-33|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardWord%20Search%20II.java)
-34|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInsert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
-35|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardRecover%20a%20Tree%20From%20Preorder%20Traversal.java)
-36|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardText%20Justification.java)
-37|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFind%20Median%20From%20Data%20Stream.java)
-38|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardNumber%20of%20Submatrices%20That%20Sum%20to%20Target.java)
-39|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFirst%20Missing%20Positive.java)
-40|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardMinimum%20Window%20Substring.java)
-41|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardStream%20of%20Characters.java)
-42|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardPrefix%20and%20Suffix%20Search.java)
-43|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
-44|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardFind%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
-45|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardSliding%20Window%20Median.java)
-46|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBasic%20Calculator.java)
-47|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBinary%20Tree%20Maximum%20Path%20Sum.java)
-48|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardInterleaving%20String.java)
-49|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardValid%20Number.java)
-50|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardRobot%20Room%20Cleaner.java)
-51|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardEmployee%20Free%20Time.java)
-52|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardDesign%20Search%20Autocomplete%20System.java)
-53|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardBasic%20Calculator%20III.java)
-54|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/HardLongest%20Increasing%20Path%20in%20a%20Matrix.java)
+1|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
+2|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
+3|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
+4|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20PostOrder%20Traversal.java)
+5|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
+6|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
+7|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parallel%20Courses.java)
+8|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
+9|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
+10|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
+11|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
+12|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
+13|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
+14|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Consecutive%20Sequence.java)
+15|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
+16|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
+17|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md)
+18|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
+19|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
+20|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
+21|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
+22|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
+23|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
+24|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
+25|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LRU%20Cache.java)
+26|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
+27|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
+28|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
+29|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
+30|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
+31|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
+32|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
+33|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
+34|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
+35|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
+36|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
+37|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20From%20Data%20Stream.java)
+38|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
+39|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
+40|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
+41|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
+42|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
+43|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+44|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
+45|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
+46|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
+47|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
+48|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Interleaving%20String.java)
+49|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
+50|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
+51|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
+52|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
+53|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
+54|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
diff --git a/Medium/README.md b/Medium/README.md
index f9bada7e..93a7cbfb 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -1,334 +1,334 @@
 # Medium LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange%20Sum%20Query%202D-Immutable.java)
-2|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination%20Sum%20III.java)
-3|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDivide%20Two%20Integers.java)
-4|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUgly%20Number%20II.java)
-5|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSet%20Matrix%20Zeroes.java)
-6|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContainer%20With%20Most%20Water.java)
-7|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSpiral%20Matrix.java)
-8|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRabbits%20in%20Forest.java)
-9|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Vertical%20Order%20Traversal.java)
-10|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBasic%20Calculator%20II.java)
-11|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCorporate%20Flight%20Bookings.java)
-12|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCustom%20Sort%20String.java)
-13|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
-14|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate%20List.java)
-15|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten%20Nested%20List%20Iterator.java)
-16|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
-17|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount%20Complete%20Tree%20Nodes.java)
-18|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20in%20Rotated%20Sorted%20Array.java)
-19|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray%20Product%20Less%20Than%20K.java)
-20|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique%20Binary%20Search%20Trees.java)
-21|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShuffle%20an%20Array.java)
-22|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutation%20in%20String.java)
-23|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
-24|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20in%20Rotated%20Sorted%20Array%20II.java)
-25|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPour%20Water.java)
-26|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Leaves%20of%20Binary%20Tree.java)
-27|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMajority%20Element%20II.java)
-28|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCourse%20Schedule%20II.java)
-29|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Circular%20Queue.java)
-30|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBattleships%20in%20a%20board.java)
-31|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Greater%20Element%20III.java)
-32|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked%20List%20Components.java)
-33|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMultiply%20Strings.java)
-34|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConvert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
-35|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20One%20Row%20to%20Tree.java)
-36|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Pruning.java)
-37|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord%20Break.java)
-38|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInterval%20List%20Intersections.java)
-39|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPow.java)
-40|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDaily%20Temperatures.java)
-41|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumImplement%20Rand10()%20Using%20Rand7().java)
-42|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPalindromic%20Substrings.java)
-43|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
-44|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20File%20System.java)
-45|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
-46|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGrumpy%20Bookstore%20Owner.java)
-47|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20Duplicates%20From%20Sorted%20Array%20II.java)
-48|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValidate%20IP%20Address.java)
-49|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBoats%20to%20Save%20People.java)
-50|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTernary%20Expression%20Parser.java)
-51|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Peak%20Element.java)
-52|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Tic-Tac-Toe.java)
-53|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKeys%20and%20Rooms.java)
-54|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCounting%20Bits.java)
-55|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSplit%20Linked%20List%20into%20Parts.java)
-56|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
-57|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTask%20Scheduler.java)
-58|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOnline%20Election.java)
-59|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Width%20Ramp.java)
-60|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTime%20Based%20Key-Value%20Store.java)
-61|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSum%20Root%20to%20Leaf%20Numbers.java)
-62|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth%20Largest%20Element%20in%20an%20Array.java)
-63|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBitwise%20AND%20of%20Numbers%20Range.java)
-64|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Longest%20Consecutive%20Sequence.java)
-65|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLargest%20BST%20Subtree.java)
-66|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPopulating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
-67|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOnline%20Stock%20Span.java)
-68|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination%20Sum%20II.java)
-69|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert%20Into%20a%20Cyclic%20Sorted%20List.java)
-70|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReconstruct%20Itinerary.java)
-71|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPartition%20Labels.java)
-72|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDistribute%20Coins%20in%20Binary%20Tree.java)
-73|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Palindromic%20Substring.java)
-74|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSimplify%20Path.java)
-75|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumZigzag%20Iterator.java)
-76|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax%20Chunks%20To%20Make%20Sorted.java)
-77|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIs%20Subsequence.java)
-78|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Linked%20List%20II.java)
-79|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumComplex%20Number%20Multiplication.java)
-80|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Binary%20Tree.java)
-81|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMeeting%20Rooms%20II.java)
-82|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFraction%20to%20Recurring%20Decimal.java)
-83|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20and%20Search%20Word%20-%20Data%20structure%20design.java)
-84|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSuper%20Ugly%20Number.java)
-85|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEscape%20The%20Ghosts.java)
-86|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax%20Increase%20to%20Keep%20City%20Skyline.java)
-87|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Path%20Sum.java)
-88|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValid%20Tic-Tac-Toe%20State.java)
-89|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShortest%20Completing%20Word.java)
-90|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium01%20Matrix.java)
-91|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAs%20Far%20from%20Land%20as%20Possible.java)
-92|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Matching%20Subsequence.java)
-93|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCar%20Pooling.java)
-94|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGenerate%20Parentheses.java)
-95|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumExclusive%20Time%20of%20Functions.java)
-96|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20Characters%20By%20Frequency.java)
-97|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMax%20Consecutives%20Ones%20II.java)
-98|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Islands.java)
-99|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Words%20in%20a%20String%20II.java)
-100|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Upside%20Down.java)
-101|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount%20Univalue%20Subtrees.java)
-102|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSplit%20BST.java)
-103|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll%20Possible%20Full%20Binary%20Trees.java)
-104|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConvert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
-105|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord%20Search.java)
-106|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20Two%20Numbers%20II.java)
-107|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20List.java)
-108|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGray%20Code.java)
-109|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate%20Function.java)
-110|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBulb%20Switcher.java)
-111|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumImplement%20Trie%20(Prefix%20Tree).java)
-112|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContains%20Duplicate%20III.java)
-113|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCopy%20List%20with%20Random%20Pointer.java)
-114|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Hit%20Counter.java)
-115|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMedium.md)
-116|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Inorder%20Traversal.java)
-117|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Product%20Subarray.java)
-118|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPrison%20Cells%20After%20N%20Days.java)
-119|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEvaluate%20Reverse%20Polish%20Notation.java)
-120|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumH-Index.java)
-121|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMini%20Parser.java)
-122|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLine%20Reflection.java)
-123|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked%20List%20Cycle%20II.java)
-124|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Size%20Subarray%20Sum.java)
-125|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Greater%20Element%20II.java)
-126|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecode%20String.java)
-127|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique%20Paths%20II.java)
-128|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShifting%20Letters.java)
-129|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray%20Sum%20Equals%20K.java)
-130|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGraph%20Valid%20Tree.java)
-131|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten%20Binary%20Tree%20to%20Linked%20List.java)
-132|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTop%20K%20Frequent%20Elements.java)
-133|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
-134|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBroken%20Calculator.java)
-135|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Twitter.java)
-136|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNested%20List%20Weight%20Sum%20II.java)
-137|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutations%20II.java)
-138|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20An%20Array.java)
-139|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConstruct%20Quad%20Tree.java)
-140|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGame%20of%20Life.java)
-141|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20Nth%20Node%20From%20End%20of%20List.java)
-142|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRandom%20Pick%20Index.java)
-143|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMy%20Calendar%20II.java)
-144|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20for%20a%20range.java)
-145|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Right%20Side%20View.java)
-146|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Substring%20Without%20Repeating%20Characters.java)
-147|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle%20Number%20III.java)
-148|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCandy%20Crush.java)
-149|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWeb%20Crawler.java)
-150|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLonely%20Pixel%20I.java)
-151|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReorganize%20String.java)
-152|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsertion%20Sort%20List.java)
-153|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPeeking%20Iterator.java)
-154|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReorder%20List.java)
-155|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique%20Paths.java)
-156|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReconstruct%20Original%20Digits%20from%20English.java)
-157|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWalls%20and%20Gates.java)
-158|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTotal%20Hamming%20Distance.java)
-159|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRectangle%20Area.java)
-160|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
-161|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Absolute%20File%20Path.java)
-162|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle%20Element%20in%20a%20Sorted%20Array.java)
-163|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Search%20Tree%20Iterator.java)
-164|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20K%20Closest%20Elements.java)
-165|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRotate%20Image.java)
-166|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Permutation.java)
-167|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Phone%20Directory.java)
-168|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumJump%20Game.java)
-169|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumH-Index%20II.java)
-170|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubarray%20Sums%20Divisible%20by%20K.java)
-171|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKill%20Process.java)
-172|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBoundary%20of%20Binary%20Tree.java)
-173|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCourse%20Schedule.java)
-174|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert%20Delete%20GetRandom%20O(1).java)
-175|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCoin%20Change%202.java)
-176|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Duplicate%20Subtrees.java)
-177|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLetter%20Tiles%20Possibilities.java)
-178|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPalindrome%20Partitioning.java)
-179|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Palindromic%20Subsequence.java)
-180|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumExpressive%20Words.java)
-181|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLinked%20List%20Random%20Node.java)
-182|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Minimum%20in%20Rotated%20Sorted%20Array.java)
-183|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum%20Closest.java)
-184|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPermutations.java)
-185|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Greater%20Node%20In%20Linked%20List.java)
-186|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMap%20Sum%20Pairs.java)
-187|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Genetic%20Mutation.java)
-188|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Binary%20Tree%20II.java)
-189|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete%20Operation%20for%20Two%20Strings.java)
-190|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInorder%20Successor%20in%20BST.java)
-191|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArray%20Nesting.java)
-192|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOutput%20Contest%20Matches.java)
-193|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSerialize%20and%20Deserialize%20BST.java)
-194|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20the%20duplicate%20number.java)
-195|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSingle%20Number%20II.java)
-196|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumStatistics%20from%20a%20Large%20Sample.java)
-197|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAccounts%20Merge.java)
-198|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Words%20in%20a%20String.java)
-199|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Duplicate%20File%20in%20System.java)
-200|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete%20Node%20in%20a%20BST.java)
-201|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIs%20Graph%20Bipartite.java)
-202|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinesweeper.java)
-203|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20K%20Digits.java)
-204|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNext%20Closest%20Time.java)
-205|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSelf%20Dividing%20Numbers.java)
-206|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReplace%20Words.java)
-207|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Increasing%20Subsequence.java)
-208|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Right%20Interval.java)
-209|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNon%20Overlapping%20Intervals.java)
-210|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange%20Addition.java)
-211|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum%20Smaller.java)
-212|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumShortest%20Way%20to%20Form%20String.java)
-213|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMissing%20Element%20in%20Sorted%20Array.java)
-214|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
-215|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Width%20of%20Binary%20Tree.java)
-216|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumProduct%20of%20Array%20Except%20self.java)
-217|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20Colors.java)
-218|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArithmetic%20Slices.java)
-219|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
-220|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPerfect%20Squares.java)
-221|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20a%202D%20Matrix.java)
-222|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSatisfisbility%20of%20Equality%20Equations.java)
-223|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Length%20of%20Pair%20Chain.java)
-224|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumQueue%20Reconstruction%20By%20Height.java)
-225|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBulls%20and%20Cows.java)
-226|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUnique%20Word%20Abbrevation.java)
-227|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRange%20Sum%20Query%20-%20Mutable.java)
-228|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDelete%20Nodes%20And%20Return%20Forest.java)
-229|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium4Sum.java)
-230|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMissing%20Ranges.java)
-231|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSentence%20Similarity%20II.java)
-232|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEvaluate%20Division.java)
-233|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20K%20Pairs%20with%20Smallest%20Sums.java)
-234|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPartition%20List.java)
-235|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEncode%20and%20Decode%20Strings.java)
-236|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecrease%20Elements%20To%20Make%20Array%20Zigzag.java)
-237|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
-238|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
-239|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Circular%20Deque.java)
-240|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDesign%20Log%20Storage%20System.java)
-241|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDecode%20Ways.java)
-242|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSort%20Transformed%20Array.java)
-243|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWiggle%20Sort.java)
-244|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPath%20Sum%20II.java)
-245|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSubsets.java)
-246|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumIncreasing%20Subsequences.java)
-247|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Distinct%20Islands.java)
-248|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20Two%20Numbers.java)
-249|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFruit%20Into%20Baskets.java)
-250|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
-251|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumComplete%20Binary%20Tree%20Insertor.java)
-252|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumClone%20Graph.java)
-253|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Preorder%20Traversal.java)
-254|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRandom%20Pick%20With%20Weight.java)
-255|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVertical%20Order%20Traversal%20Of%20Binary%20Tree.java)
-256|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20Duplicates%20from%20Sorted%20List%20II.java)
-257|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSearch%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
-258|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRectangle%20Overlap.java)
-259|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAnalyze%20User%20Website%20Visit%20Pattern.java)
-260|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombination%20Sum.java)
-261|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSolve%20the%20Equation.java)
-262|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumThe%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
-263|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVerify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
-264|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOptimal%20Division.java)
-265|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumScore%20of%20Parentheses.java)
-266|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMerge%20Intervals.java)
-267|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth%20Smallest%20Element%20in%20a%20BST.java)
-268|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCoin%20Change.java)
-269|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20the%20Celebrity.java)
-270|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumArray%20Circular%20Loop.java)
-271|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSnapshot%20Array.java)
-272|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTop%20K%20Frequent%20Words.java)
-273|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAsteroid%20Collision.java)
-274|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumEncode%20and%20Decode%20TinyURL.java)
-275|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInsert%20into%20a%20Binary%20Search%20Tree.java)
-276|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWord%20Ladder.java)
-277|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInorder%20Successor%20in%20BST%20II.java)
-278|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20and%20Replace%20Pattern.java)
-279|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumNumber%20of%20Longest%20Increasing%20Subsequence.java)
-280|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRemove%20Comments.java)
-281|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPancake%20Sorting.java)
-282|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Size%20Subarray%20Sum%20Equals%20k.java)
-283|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium3Sum.java)
-284|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumValid%20Triangle%20Number.java)
-285|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumKth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
-286|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumString%20to%20Integer(atoi).java)
-287|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAll%20Paths%20From%20Source%20to%20Target.java)
-288|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumBinary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
-289|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFriend%20Circles.java)
-290|[Swap Nodes in Pair](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSwap%20Nodes%20in%20Pair.java)
-291|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPlus%20One%20Linked%20List.java)
-292|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumTeemo%20Attacking.java)
-293|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCompare%20Version%20Numbers.java)
-294|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSmallest%20String%20Starting%20From%20Leaf.java)
-295|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCount%20Numbers%20With%20Unique%20Digits.java)
-296|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumUncrossed%20Lines.java)
-297|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumVowel%20Spellchecker.java)
-298|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumContiguous%20Array.java)
-299|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Well-Performing%20Interval.java)
-300|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Bottom%20Left%20Tree%20Value.java)
-301|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumScore%20After%20Flipping%20Matrix.java)
-302|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium4%20Sum%20II.java)
-303|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMost%20Frequent%20Subtree%20Sum.java)
-304|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumCombinations.java)
-305|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRLE%20Iterator.java)
-306|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSpiral%20Matrix%20II.java)
-307|[Find Largest Value in Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20Largest%20Value%20in%20Tree%20Row.java)
-308|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMinimum%20Time%20Difference.java)
-309|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20all%20Duplicates%20in%20an%20Array.java)
-310|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumDiagonal%20Traverse.java)
-311|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumPrint%20Binary%20Tree.java)
-312|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMasking%20Personal%20Information.java)
-313|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumSummary%20Ranges.java)
-314|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLetter%20Combinations%20of%20a%20Phone%20Number.java)
-315|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOdd%20Even%20Linked%20Lists.java)
-316|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
-317|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumZigZag%20Conversion.java)
-318|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumWater%20&%20Jug%20Problem.java)
-319|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFind%20and%20Replace%20in%20String.java)
-320|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumConstruct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
-321|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumFlatten%202D%20Vector.java)
-322|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumHand%20of%20Straights.java)
-323|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMaximum%20Average%20Subtree.java)
-324|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumRepeated%20DNA%20Sequences.java)
-325|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumInteger%20To%20Roman.java)
-326|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumMy%20Calendar%20I.java)
-327|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumLongest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
-328|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumGroup%20Shifted%20Strings.java)
-329|[Reverse Nodes in k-group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumReverse%20Nodes%20in%20k-group.java)
-330|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumOne%20Edit%20Distance.java)
-331|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/MediumAdd%20Bold%20Tag%20in%20String.java)
+1|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
+2|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
+3|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
+4|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
+5|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
+6|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
+7|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
+8|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
+9|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
+10|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
+11|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
+12|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
+13|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
+14|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
+15|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
+16|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
+17|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
+18|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
+19|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
+20|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
+21|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
+22|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
+23|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
+24|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
+25|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
+26|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
+27|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
+28|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
+29|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
+30|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
+31|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
+32|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
+33|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
+34|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
+35|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
+36|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
+37|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
+38|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
+39|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
+40|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
+41|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
+42|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
+43|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
+44|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
+45|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
+46|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
+47|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
+48|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
+49|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
+50|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
+51|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
+52|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
+53|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
+54|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Counting%20Bits.java)
+55|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20into%20Parts.java)
+56|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
+57|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
+58|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
+59|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
+60|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
+61|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
+62|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
+63|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
+64|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
+65|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
+66|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
+67|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
+68|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
+69|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
+70|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Itinerary.java)
+71|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
+72|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
+73|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
+74|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
+75|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
+76|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
+77|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Subsequence.java)
+78|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
+79|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
+80|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
+81|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
+82|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
+83|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20and%20Search%20Word%20-%20Data%20structure%20design.java)
+84|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
+85|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
+86|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
+87|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
+88|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
+89|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
+90|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
+91|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
+92|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
+93|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
+94|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
+95|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
+96|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
+97|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
+98|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
+99|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
+100|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
+101|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
+102|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
+103|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
+104|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
+105|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
+106|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
+107|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
+108|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
+109|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
+110|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
+111|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
+112|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
+113|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
+114|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
+115|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md)
+116|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Inorder%20Traversal.java)
+117|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
+118|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
+119|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
+120|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
+121|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
+122|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
+123|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
+124|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
+125|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
+126|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
+127|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
+128|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
+129|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
+130|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
+131|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
+132|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
+133|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
+134|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
+135|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
+136|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
+137|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
+138|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
+139|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
+140|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
+141|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
+142|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
+143|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
+144|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
+145|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
+146|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
+147|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
+148|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
+149|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
+150|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
+151|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
+152|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
+153|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
+154|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
+155|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
+156|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
+157|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
+158|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
+159|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
+160|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
+161|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
+162|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
+163|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
+164|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
+165|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
+166|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
+167|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
+168|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
+169|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
+170|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
+171|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
+172|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
+173|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
+174|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
+175|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
+176|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
+177|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
+178|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
+179|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
+180|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
+181|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
+182|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
+183|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
+184|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
+185|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
+186|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
+187|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
+188|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
+189|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
+190|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
+191|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
+192|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
+193|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
+194|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20duplicate%20number.java)
+195|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
+196|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
+197|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
+198|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
+199|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
+200|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
+201|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
+202|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
+203|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
+204|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
+205|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
+206|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
+207|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
+208|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
+209|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
+210|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
+211|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
+212|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
+213|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
+214|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
+215|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
+216|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
+217|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
+218|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
+219|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
+220|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
+221|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
+222|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
+223|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
+224|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
+225|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulls%20and%20Cows.java)
+226|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
+227|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
+228|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
+229|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
+230|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Ranges.java)
+231|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
+232|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
+233|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
+234|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
+235|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
+236|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
+237|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
+238|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
+239|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
+240|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
+241|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
+242|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
+243|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
+244|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
+245|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
+246|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
+247|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
+248|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
+249|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
+250|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
+251|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
+252|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
+253|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
+254|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
+255|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vertical%20Order%20Traversal%20Of%20Binary%20Tree.java)
+256|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
+257|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
+258|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Overlap.java)
+259|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
+260|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
+261|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
+262|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
+263|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
+264|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
+265|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
+266|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
+267|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
+268|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
+269|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
+270|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
+271|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
+272|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
+273|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
+274|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
+275|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
+276|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
+277|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
+278|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
+279|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
+280|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
+281|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
+282|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
+283|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
+284|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
+285|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
+286|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer(atoi).java)
+287|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
+288|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
+289|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
+290|[Swap Nodes in Pair](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pair.java)
+291|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
+292|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Teemo%20Attacking.java)
+293|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
+294|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
+295|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
+296|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
+297|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
+298|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
+299|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
+300|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
+301|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
+302|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
+303|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
+304|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
+305|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
+306|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
+307|[Find Largest Value in Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Tree%20Row.java)
+308|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
+309|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
+310|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
+311|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
+312|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
+313|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Summary%20Ranges.java)
+314|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
+315|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
+316|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
+317|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
+318|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
+319|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
+320|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
+321|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
+322|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
+323|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
+324|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
+325|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
+326|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
+327|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
+328|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
+329|[Reverse Nodes in k-group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20k-group.java)
+330|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
+331|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
diff --git a/script.py b/script.py
index 7af387c6..4fe80e71 100755
--- a/script.py
+++ b/script.py
@@ -26,7 +26,7 @@
     for file_name in onlyfiles:
         only_name = file_name[:file_name.find('.')]
         updated_file_name = file_name.replace(' ', '%20')
-        f.write(str(count) + "|" + '[{}]({})\n'.format(only_name, (tree_path + level + updated_file_name)))
+        f.write(str(count) + "|" + '[{}]({})\n'.format(only_name, (tree_path + level + "/" + updated_file_name)))
         count = count + 1
     print(level + ": " + str(count))
     f.close()

From 70c3ae8ace96cd01960d9f0333c4daaa453f0367 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Nov 2019 14:55:39 -0800
Subject: [PATCH 0043/2175] Update README.md

---
 README.md | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 95f863a5..1c006c04 100644
--- a/README.md
+++ b/README.md
@@ -3,8 +3,6 @@
 ## Solutions to Leetcode problems in Java
 Category | Count
 --- | ---
-Easy | 282
-Medium | 331
-Hard | 54
-
-
+[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy) | 282
+[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium) | 331
+[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard) | 54

From 41ea135f961f86cb2c1039f6e6f496c5dd5013c0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Nov 2019 20:11:27 -0800
Subject: [PATCH 0044/2175] Create Open The Lock.java

---
 Medium/Open The Lock.java | 41 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Medium/Open The Lock.java

diff --git a/Medium/Open The Lock.java b/Medium/Open The Lock.java
new file mode 100644
index 00000000..926e8521
--- /dev/null
+++ b/Medium/Open The Lock.java	
@@ -0,0 +1,41 @@
+class Solution {
+    public int openLock(String[] deadends, String target) {
+        Set<String> deadEndSet = new HashSet<>(Arrays.asList(deadends));
+        if (deadEndSet.contains(target) || deadEndSet.contains("0000")) {
+            return -1;
+        }
+        Queue<String> queue = new LinkedList<>();
+        Set<String> seen = new HashSet<>();
+        queue.add("0000");
+        seen.add("0000");
+        int steps = 0;
+        int[] rotations = {-1, 1};
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                String removed = queue.remove();
+                if (removed.equals(target)) {
+                    return steps;
+                }
+                if (deadEndSet.contains(removed)) {
+                    continue;
+                }
+                for (int j = 0; j < 4; j++) {
+                    for (int rotation : rotations) {
+                        int changedVal = ((removed.charAt(j) - '0') + rotation + 10) % 10;
+                        String newRotation = new StringBuilder()
+                                                    .append(removed.substring(0,j))                                                                                         .append(changedVal)
+                                                    .append(removed.substring(j + 1))
+                                                    .toString();
+                        if (!seen.contains(newRotation)) {
+                            seen.add(newRotation);
+                            queue.add(newRotation);
+                        }
+                    }
+                }
+            }
+            steps++;
+        }
+        return -1;
+    }
+}

From 1948214f7396672ecd71aeef3ef97e797d76575b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Nov 2019 20:13:06 -0800
Subject: [PATCH 0045/2175] Update README.md

---
 Medium/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Medium/README.md b/Medium/README.md
index 93a7cbfb..3982b417 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -332,3 +332,4 @@ S.no | Coding Problem
 329|[Reverse Nodes in k-group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20k-group.java)
 330|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
 331|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
+332|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/Open%20The%20Lock.java)

From c271ea2deeec51bad2e740df7faeb852a6eef988 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Nov 2019 19:01:29 -0800
Subject: [PATCH 0046/2175] Updated Keys and Rooms.java to iterative version

---
 Medium/Keys and Rooms.java | 33 +++++++++++++--------------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/Medium/Keys and Rooms.java b/Medium/Keys and Rooms.java
index a62750df..6a2f8c3f 100644
--- a/Medium/Keys and Rooms.java	
+++ b/Medium/Keys and Rooms.java	
@@ -1,26 +1,19 @@
 class Solution {
-    int[] keys;
     public boolean canVisitAllRooms(List<List<Integer>> rooms) {
-        keys = new int[rooms.size()];
-        keys[0] = 1;
-        
-        dfs(rooms, 0);
-        
-        for (int key : keys) {
-            if (key == 0) {
-                return false;
-            }
-        }
-        
-        return true;
-    }
-    
-    private void dfs(List<List<Integer>> rooms, int k) {
-        for (int key : rooms.get(k)) {
-            if (keys[key] == 0) {
-                keys[key]++;
-                dfs(rooms, key);
+        Stack<Integer> stack = new Stack<>();
+        Set<Integer> set = new HashSet<>();
+        set.add(0);
+        stack.add(0);
+        while (!stack.isEmpty()) {
+            int keyPopped = stack.pop();
+            List<Integer> keys = rooms.get(keyPopped);
+            for (Integer key : keys) {
+                if (!set.contains(key)) {
+                    stack.push(key);
+                    set.add(key);
+                }
             }
         }
+        return set.size() == rooms.size();
     }
 }

From b6286f7d9f19d84e6f3f6d9747a0ae973aece53d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Nov 2019 18:47:23 -0800
Subject: [PATCH 0047/2175] Create Target Sum.java

---
 Medium/Target Sum.java | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Target Sum.java

diff --git a/Medium/Target Sum.java b/Medium/Target Sum.java
new file mode 100644
index 00000000..d5c5e585
--- /dev/null
+++ b/Medium/Target Sum.java	
@@ -0,0 +1,34 @@
+class Solution {
+    int count;
+    public int findTargetSumWays(int[] nums, int S) {
+        int[][] dp = new int[nums.length][2001];
+        for (int[] row : dp) {
+            Arrays.fill(row, Integer.MIN_VALUE);
+        }
+        return calculateWays(nums, 0, 0, S, dp);
+    }
+    
+    private void calculateWaysDfs(int[] nums, int idx, int S) {
+        if (idx == nums.length) {
+            if (S == 0) {
+                count++;   
+            }
+            return;
+        }
+        dfs(nums, idx + 1, S - nums[idx]);
+        dfs(nums, idx + 1, S + nums[idx]);
+    }
+    
+    private int calculateWaysDp(int[] nums, int idx, int sum, int S, int[][] dp) {
+        if (idx == nums.length) {
+            return sum == S ? 1 : 0;
+        }
+        if (dp[idx][sum + 1000] != Integer.MIN_VALUE) {
+            return dp[idx][sum + 1000];
+        }
+        int add = calculateWaysDp(nums, idx + 1, sum + nums[idx], S, dp);
+        int sub = calculateWaysDp(nums, idx + 1, sum - nums[idx], S, dp);
+        dp[idx][sum + 1000] = add + sub;
+        return dp[idx][sum + 1000];
+    }
+}

From fc8e4e43b43b1f44a386ac64d9adc56ebc9d8ca0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Nov 2019 18:49:03 -0800
Subject: [PATCH 0048/2175] Updated README to add Target Sum

---
 Medium/README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Medium/README.md b/Medium/README.md
index 3982b417..3907727e 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -333,3 +333,5 @@ S.no | Coding Problem
 330|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
 331|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
 332|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/Open%20The%20Lock.java)
+333|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/Target%20Sum.java)
+

From 98f0f856f9347ecf044ef649b88968bdb13139b4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 18 Nov 2019 08:34:10 -0800
Subject: [PATCH 0049/2175] Create Minimum Index Sum of Two Lists.java

---
 Easy/Minimum Index Sum of Two Lists.java | 38 ++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Easy/Minimum Index Sum of Two Lists.java

diff --git a/Easy/Minimum Index Sum of Two Lists.java b/Easy/Minimum Index Sum of Two Lists.java
new file mode 100644
index 00000000..48961a20
--- /dev/null
+++ b/Easy/Minimum Index Sum of Two Lists.java	
@@ -0,0 +1,38 @@
+class Solution {
+    public String[] findRestaurant(String[] list1, String[] list2) {
+        Map<String, Integer> map1 = createMap(list1);
+        Map<String, Integer> map2 = createMap(list2);
+        int minIndexSum = Integer.MAX_VALUE;
+        int count = 0;
+        for (String key : map1.keySet()) {
+            if (map2.containsKey(key)) {
+                int idxSum = map1.get(key) + map2.get(key);
+                if (idxSum < minIndexSum) {
+                    minIndexSum = idxSum;
+                    count = 1;
+                }
+                else if (idxSum == minIndexSum){
+                    count++;
+                }
+            }
+        }
+        String[] ans = new String[count];
+        int idx = 0;
+        for (String key : map1.keySet()) {
+            if (map2.containsKey(key)) {
+                if (map1.get(key) + map2.get(key) == minIndexSum) {
+                    ans[idx++] = key;
+                }
+            }
+        }
+        return ans;
+    }
+
+    private Map<String, Integer> createMap(String[] list) {
+        Map<String, Integer> map = new HashMap<>();
+        for (int i = 0; i < list.length; i++) {
+            map.put(list[i], i);
+        }
+        return map;
+    }
+}

From 4e179ac0748d2422ad24530cd8af4bcea2710d2a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Nov 2019 06:10:03 -0800
Subject: [PATCH 0050/2175] Create Valid Sudoku.java

---
 Medium/Valid Sudoku.java | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Valid Sudoku.java

diff --git a/Medium/Valid Sudoku.java b/Medium/Valid Sudoku.java
new file mode 100644
index 00000000..e35dd7c3
--- /dev/null
+++ b/Medium/Valid Sudoku.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public boolean isValidSudoku(char[][] board) {
+        HashSet<Character>[] rowSet = new HashSet[9];
+        HashSet<Character>[] colSet = new HashSet[9];
+        HashSet<Character>[] boxSet = new HashSet[9];
+        for (int i = 0; i < 9; i++) {
+            rowSet[i] = new HashSet<>();
+            colSet[i] = new HashSet<>();
+            boxSet[i] = new HashSet<>();
+        }
+        for (int i = 0; i < 9; i++) {
+            for (int j = 0; j < 9; j++) {
+                if (board[i][j] != '.') {
+                    char val = board[i][j];
+                    int boxIdx = (i / 3) * 3 + j / 3;
+                    if (rowSet[i].contains(val) || colSet[j].contains(val) || boxSet[boxIdx].contains(val)) {
+                        return false;
+                    }
+                    rowSet[i].add(val);
+                    colSet[j].add(val);
+                    boxSet[boxIdx].add(val);
+                }
+            }
+        }
+        return true;
+    }
+}

From 8d6afe667242dfb87b5e9580223b072f57282633 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 21 Nov 2019 15:50:25 -0800
Subject: [PATCH 0051/2175] Create Find Elements in a Contaminated Binary
 Tree.java

---
 ...lements in a Contaminated Binary Tree.java | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/Find Elements in a Contaminated Binary Tree.java

diff --git a/Medium/Find Elements in a Contaminated Binary Tree.java b/Medium/Find Elements in a Contaminated Binary Tree.java
new file mode 100644
index 00000000..2015bd92
--- /dev/null
+++ b/Medium/Find Elements in a Contaminated Binary Tree.java	
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class FindElements {
+    TreeNode root;
+    Set<Integer> set;
+    public FindElements(TreeNode root) {
+        set = new HashSet<>();
+        buildTree(root, 0);
+    }
+    
+    private void buildTree(TreeNode root, int val) {
+        if (root == null) {
+            return;
+        }
+        root.val = val;
+        set.add(val);
+        buildTree(root.left, 2 * val + 1);
+        buildTree(root.right, 2 * val + 2);
+    }
+    
+    public boolean find(int target) {
+        return set.contains(target);
+    }
+}
+
+/**
+ * Your FindElements object will be instantiated and called as such:
+ * FindElements obj = new FindElements(root);
+ * boolean param_1 = obj.find(target);
+ */

From d9b3f3866bc566c423cce1d8e776eadb85cdd077 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Nov 2019 21:09:42 -0800
Subject: [PATCH 0052/2175] Update Design Linked List.java

---
 Easy/Design Linked List.java | 81 ++++++++++++++++++++++++++++++------
 1 file changed, 69 insertions(+), 12 deletions(-)

diff --git a/Easy/Design Linked List.java b/Easy/Design Linked List.java
index 9788cd08..50533d0a 100644
--- a/Easy/Design Linked List.java	
+++ b/Easy/Design Linked List.java	
@@ -1,48 +1,105 @@
 class MyLinkedList {
 
     /** Initialize your data structure here. */
-    List<Integer> list;
+    Node head;
+    Node tail;
+    int count;
     public MyLinkedList() {
-        list = new ArrayList<>();
+        head = new Node(-1);
+        tail = new Node(-1);
+        head.next = tail;
+        tail.prev = head;
+        count = 0;
     }
     
     /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
     public int get(int index) {
-        if (index >= list.size() || index < 0) {
+        if (index < 0 || index >= count) {
             return -1;
         }
-        
-        return list.get(index);
+        Node curr = head.next;
+        int idx = 0;
+        while (idx < index) {
+            idx++;
+            curr = curr.next;
+        }
+        return curr.val;
     }
     
     /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
     public void addAtHead(int val) {
-        list.add(0, val);
+        Node newNode = new Node(val);
+        newNode.next = head.next;
+        newNode.prev = head;
+        head.next.prev = newNode;
+        head.next = newNode;
+        count++;
     }
     
     /** Append a node of value val to the last element of the linked list. */
     public void addAtTail(int val) {
-        list.add(val);
+        Node newNode = new Node(val);
+        newNode.prev = tail.prev;
+        newNode.next = tail;
+        tail.prev.next = newNode;
+        tail.prev = newNode;
+        count++;
     }
     
     /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
     public void addAtIndex(int index, int val) {
-        if (index > list.size()) {
+        if (index < 0 || index > count) {
             return;
         }
-        if (index == list.size()) {
+        if (index == 0) {
+            addAtHead(val);
+        }
+        else if (index == count) {
             addAtTail(val);
         }
         else {
-            list.add(index, val);
+            int idx = 0;
+            Node curr = head;
+            while (idx < index) {
+                idx++;
+                curr = curr.next;
+            }
+            Node newNode = new Node(val);
+            newNode.prev = curr;
+            newNode.next = curr.next;
+            curr.next.prev = newNode;
+            curr.next = newNode;
+            count++;
         }
     }
     
     /** Delete the index-th node in the linked list, if the index is valid. */
     public void deleteAtIndex(int index) {
-        if (index >= 0 && index < list.size()) {
-            list.remove(index);
+        if (index < 0 || index >= count) {
+            return;
+        }
+        int idx = 0;
+        Node curr = head;
+        while (idx < index) {
+            idx++;
+            curr = curr.next;
         }
+        Node next = curr.next.next;
+        next.prev = curr;
+        curr.next = next;
+        count--;
+    }
+}
+
+class Node {
+    int val;
+    Node next;
+    Node prev;
+    
+    public Node(int val) {
+        this.val = val;
+        next = null;
+        prev = null;
     }
 }
 

From 6aea02664f124f2f49a7f6ab82e30cb7672d14fe Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Nov 2019 21:16:04 -0800
Subject: [PATCH 0053/2175] Create Count Servers That Communicate.java

---
 Medium/Count Servers That Communicate.java | 31 ++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Count Servers That Communicate.java

diff --git a/Medium/Count Servers That Communicate.java b/Medium/Count Servers That Communicate.java
new file mode 100644
index 00000000..81a2c8ff
--- /dev/null
+++ b/Medium/Count Servers That Communicate.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int countServers(int[][] grid) {
+        if (grid.length == 0 || grid[0].length == 0) {
+            return 0;
+        }
+        int numRows = grid.length;
+        int numCols = grid[0].length;
+        int[] rowCount = new int[numRows];
+        int[] colCount = new int[numCols];
+        int numOfServers = 0;
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                if (grid[i][j] == 1) {
+                    numOfServers++;
+                    rowCount[i]++;
+                    colCount[j]++;
+                }
+            }
+        }
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                if (grid[i][j] == 1) {
+                    if (rowCount[i] == 1 && colCount[j] == 1) {
+                        numOfServers--;
+                    }
+                }
+            }
+        }
+        return numOfServers;
+    }
+}

From b638e265e58aaa94d2a08994bd561b208ebae769 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Nov 2019 08:30:50 -0800
Subject: [PATCH 0054/2175] Update Design Hit Counter.java

---
 Medium/Design Hit Counter.java | 33 ++++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/Medium/Design Hit Counter.java b/Medium/Design Hit Counter.java
index bab20249..374d33c3 100644
--- a/Medium/Design Hit Counter.java	
+++ b/Medium/Design Hit Counter.java	
@@ -1,25 +1,36 @@
 class HitCounter {
 
     /** Initialize your data structure here. */
-    Queue<Integer> queue;
+    int[] times;
+    int[] hits;
     public HitCounter() {
-        queue = new LinkedList<>();
+        times = new int[300];
+        hits = new int[300];
     }
-
+    
     /** Record a hit.
-     @param timestamp - The current timestamp (in seconds granularity). */
+        @param timestamp - The current timestamp (in seconds granularity). */
     public void hit(int timestamp) {
-        queue.add(timestamp);
+        int idx = timestamp % 300;
+        if (times[idx] != timestamp) {
+            times[idx] = timestamp;
+            hits[idx] = 1;
+        }
+        else {
+            hits[idx]++;
+        }
     }
-
+    
     /** Return the number of hits in the past 5 minutes.
-     @param timestamp - The current timestamp (in seconds granularity). */
+        @param timestamp - The current timestamp (in seconds granularity). */
     public int getHits(int timestamp) {
-        while (!queue.isEmpty() && timestamp - queue.peek() >= 300) {
-            queue.remove();
+        int totalCount = 0;
+        for (int i = 0; i < 300; i++) {
+            if (timestamp - times[i] < 300) {
+                totalCount += hits[i];
+            }
         }
-
-        return queue.size();
+        return totalCount;
     }
 }
 

From 2486a234e4eae888cb0e94f55ddb71f5647976e6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 27 Nov 2019 08:53:08 -0800
Subject: [PATCH 0055/2175] Create Design A Leaderboard.java

---
 Medium/Design A Leaderboard.java | 45 ++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 Medium/Design A Leaderboard.java

diff --git a/Medium/Design A Leaderboard.java b/Medium/Design A Leaderboard.java
new file mode 100644
index 00000000..9a5ca751
--- /dev/null
+++ b/Medium/Design A Leaderboard.java	
@@ -0,0 +1,45 @@
+class Leaderboard {
+    Map<Integer, Integer> scoreMap;
+    Map<Integer, Set<Integer>> playerMap;
+    public Leaderboard() {
+        scoreMap = new HashMap<>();
+        playerMap = new TreeMap<>(Collections.reverseOrder());
+    }
+
+    public void addScore(int playerId, int score) {
+        if (scoreMap.containsKey(playerId)) {
+            int prevScore = scoreMap.get(playerId);
+            playerMap.get(prevScore).remove(playerId);
+        }
+        scoreMap.put(playerId, scoreMap.getOrDefault(playerId, 0) + score);
+        playerMap.computeIfAbsent(scoreMap.get(playerId), k -> new HashSet<>()).add(playerId);
+    }
+
+    public int top(int K) {
+        int sum = 0;
+        for (Integer key : playerMap.keySet()) {
+            int count = Math.min(K, playerMap.get(key).size());
+            sum += key * count;
+            K -= count;
+            if (K == 0) {
+                break;
+            }
+        }
+        return sum;
+    }
+
+    public void reset(int playerId) {
+        int prevScore = scoreMap.get(playerId);
+        playerMap.get(prevScore).remove(playerId);
+        scoreMap.put(playerId, 0);
+        playerMap.computeIfAbsent(0, k -> new HashSet<>()).add(playerId);
+    }
+}
+
+/**
+ * Your Leaderboard object will be instantiated and called as such:
+ * Leaderboard obj = new Leaderboard();
+ * obj.addScore(playerId,score);
+ * int param_2 = obj.top(K);
+ * obj.reset(playerId);
+ */

From 19ba49d0d6f7b08d7266a0f2ab5df0078446e8f1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 30 Nov 2019 15:19:17 -0800
Subject: [PATCH 0056/2175] Added 2 solutions

---
 Easy/Hexspeak.java          | 24 ++++++++++++++++++++++
 Medium/Remove Interval.java | 41 +++++++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+)
 create mode 100644 Easy/Hexspeak.java
 create mode 100644 Medium/Remove Interval.java

diff --git a/Easy/Hexspeak.java b/Easy/Hexspeak.java
new file mode 100644
index 00000000..dee2210a
--- /dev/null
+++ b/Easy/Hexspeak.java
@@ -0,0 +1,24 @@
+class Solution {
+    Integer[] keys = {0, 1, 10, 11, 12, 13, 14, 15};
+    String[] values = {"O", "I", "A", "B", "C", "D", "E", "F"};
+    Map<Long, String> map;
+    public String toHexspeak(String num) {
+        map = new HashMap<>();
+        for (int i = 0; i < keys.length; i++) {
+            map.put((long) keys[i], values[i]);
+        }
+        StringBuilder sb = new StringBuilder();
+        Long n = Long.parseLong(num);
+        while (n > 0) {
+            Long quot = n % 16;
+            n /= 16;
+            if (map.containsKey(quot)) {
+                sb.append(map.get(quot));
+            }
+            else {
+                return "ERROR";
+            }
+        }
+        return sb.reverse().toString();
+    }
+}
diff --git a/Medium/Remove Interval.java b/Medium/Remove Interval.java
new file mode 100644
index 00000000..4ebbcf9e
--- /dev/null
+++ b/Medium/Remove Interval.java	
@@ -0,0 +1,41 @@
+class Solution {
+    public List<List<Integer>> removeInterval(int[][] intervals, int[] toBeRemoved) {
+        List<List<Integer>> list = new ArrayList<>();
+        int removeStart = toBeRemoved[0];
+        int removeEnd = toBeRemoved[1];
+        for (int[] interval : intervals) {
+            int start = interval[0];
+            int end = interval[1];
+            // Case 1: Overlap the removal interval. Skip this interval
+            if (start >= removeStart && end <= removeEnd) {
+                continue;
+            }
+            // Case 2 and 3: Completely miss out the removal interval either on left side or right side of number line.
+            // Add the complete interval
+            if ((start <= removeStart && end <= removeStart) ||
+                (start >= removeEnd && end >= removeEnd)) {
+                list.add(Arrays.asList(start, end));
+                continue;
+            }
+            // Case 4: Interval partially overlaps on left side of removal interval on number line. 
+            // Add the modified interval
+            if (start <= removeStart) {
+                int tempStart = Math.min(start, removeStart);
+                int tempEnd = Math.max(start, removeStart);
+                if (tempStart != tempEnd) {
+                    list.add(Arrays.asList(tempStart, tempEnd));
+                }
+            }
+            // Case 5: Interval partially overlaps on right side of removal interval on number line. 
+            // Add the modified interval
+            if (end >= removeEnd) {
+                int tempStart = Math.min(end, removeEnd);
+                int tempEnd = Math.max(end, removeEnd);
+                if (tempStart != tempEnd) {
+                    list.add(Arrays.asList(tempStart, tempEnd));
+                }
+            }
+        }
+        return list;
+    }
+}

From 108d5785e1bb048d70813abdaeb59b0dd093d4a9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 1 Dec 2019 17:52:20 -0800
Subject: [PATCH 0057/2175] Added 2 solutions

---
 Easy/Find Winner on a Tic Tac Toe Game.java   | 49 +++++++++++++++++++
 ... Burgers with No Waste of Ingredients.java | 17 +++++++
 2 files changed, 66 insertions(+)
 create mode 100644 Easy/Find Winner on a Tic Tac Toe Game.java
 create mode 100644 Medium/Number of Burgers with No Waste of Ingredients.java

diff --git a/Easy/Find Winner on a Tic Tac Toe Game.java b/Easy/Find Winner on a Tic Tac Toe Game.java
new file mode 100644
index 00000000..c5a27339
--- /dev/null
+++ b/Easy/Find Winner on a Tic Tac Toe Game.java	
@@ -0,0 +1,49 @@
+class Solution {
+    int[] rowCount;
+    int[] colCount;
+    int[] diagCount;
+    public String tictactoe(int[][] moves) {
+        rowCount = new int[3];
+        colCount = new int[3];
+        diagCount = new int[2];
+        int numOfMoves = 0;
+        for (int i = 0; i < moves.length; i++) {
+            int x = moves[i][0];
+            int y = moves[i][1];
+            int move = i % 2 == 0 ? 1 : -1;
+            updateBoard(x, y, move);
+            numOfMoves++;
+            if (checkForWinner(x, y)) {
+                return i % 2 == 0 ? "A" : "B";
+            }
+        }
+        return numOfMoves == 9 ? "Draw" : "Pending";
+    }
+    
+    private boolean checkForWinner(int x, int y) {
+        if (rowCount[x] == 3 || rowCount[x] == -3) {
+            return true;
+        }
+        if (colCount[y] == 3 || colCount[y] == -3) {
+            return true;
+        }
+        if (x == y && (diagCount[0] == 3 || diagCount[0] == -3)) {
+            return true;
+        }
+        if (x + y == 2 && (diagCount[1] == 3 || diagCount[1] == -3)) {
+            return true;
+        }
+        return false;
+    }
+    
+    private void updateBoard(int x, int y, int move) {
+        rowCount[x] += move;
+        colCount[y] += move;
+        if (x == y) {
+            diagCount[0] += move;
+        }
+        if (x + y == 2) {
+            diagCount[1] += move;
+        }
+    }
+}
diff --git a/Medium/Number of Burgers with No Waste of Ingredients.java b/Medium/Number of Burgers with No Waste of Ingredients.java
new file mode 100644
index 00000000..ebf00c37
--- /dev/null
+++ b/Medium/Number of Burgers with No Waste of Ingredients.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public List<Integer> numOfBurgers(int tomatoSlices, int cheeseSlices) {
+        int twoX = tomatoSlices - 2 * cheeseSlices;
+        int x = twoX / 2;
+        int y = cheeseSlices - x;
+        return twoX >= 0 && twoX % 2 == 0 && y >= 0 ? Arrays.asList(x, y) : new ArrayList<>();
+    }
+}
+
+/*
+4x + 2y = tomato
+x + y = cheese
+=>
+2x = tomato - 2 * cheese
+x = (tomato - 2 * cheese) / 2
+y = cheese - x
+*/

From 13f13ea1544204de2d71c366a2d63807b14adee4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 2 Dec 2019 20:34:46 -0800
Subject: [PATCH 0058/2175] Added 1 solution

---
 Medium/Delete Tree Nodes.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Delete Tree Nodes.java

diff --git a/Medium/Delete Tree Nodes.java b/Medium/Delete Tree Nodes.java
new file mode 100644
index 00000000..ff35d30a
--- /dev/null
+++ b/Medium/Delete Tree Nodes.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int deleteTreeNodes(int nodes, int[] parent, int[] value) {
+        for (int i = nodes - 1; i > 0; i--) {
+            value[parent[i]] += value[i];
+        }
+        Set<Integer> set = new HashSet<>();
+        for (int i = 0; i < nodes; i++) {
+            if (set.contains(parent[i])) {
+                value[i] = 0;
+            }
+            if (value[i] == 0) {
+                set.add(i);
+            }
+        }
+        return nodes - set.size();
+    }
+}

From a58f15b181eaf3df4c6f390a8afe5ad748e51676 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 6 Dec 2019 21:45:07 -0800
Subject: [PATCH 0059/2175] Create Find Anagram Mappings.java

---
 Easy/Find Anagram Mappings.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Find Anagram Mappings.java

diff --git a/Easy/Find Anagram Mappings.java b/Easy/Find Anagram Mappings.java
new file mode 100644
index 00000000..74ab5769
--- /dev/null
+++ b/Easy/Find Anagram Mappings.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int[] anagramMappings(int[] A, int[] B) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < B.length; i++) {
+            map.put(B[i], i);
+        }
+        int[] ans = new int[A.length];
+        for (int i = 0; i < A.length; i++) {
+            ans[i] = map.get(A[i]);
+        }
+        return ans;
+    }
+}

From 13dfde95758e123d8b13edec8ddb14e69ec88c3e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 8 Dec 2019 09:49:26 -0800
Subject: [PATCH 0060/2175] Added 2 solutions

---
 ...oduct and Sum of Digits of an Integer.java | 26 ++++++++++++++++++
 ...e Given the Group Size They Belong To.java | 27 +++++++++++++++++++
 2 files changed, 53 insertions(+)
 create mode 100644 Easy/Subtract the Product and Sum of Digits of an Integer.java
 create mode 100644 Medium/Group the People Given the Group Size They Belong To.java

diff --git a/Easy/Subtract the Product and Sum of Digits of an Integer.java b/Easy/Subtract the Product and Sum of Digits of an Integer.java
new file mode 100644
index 00000000..200b6940
--- /dev/null
+++ b/Easy/Subtract the Product and Sum of Digits of an Integer.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int subtractProductAndSum(int n) {
+        return getProduct(n) - getSum(n);
+    }
+    
+    private int getProduct(int n) {
+        if (n == 0) {
+            return 0;
+        }
+        int fact = 1;
+        while (n > 0) {
+            fact *= n % 10;
+            n /= 10;
+        }
+        return fact;
+    }
+    
+    private int getSum(int n) {
+        int sum = 0;
+        while (n > 0) {
+            sum += n % 10;
+            n /= 10;
+        }
+        return sum;
+    }
+}
diff --git a/Medium/Group the People Given the Group Size They Belong To.java b/Medium/Group the People Given the Group Size They Belong To.java
new file mode 100644
index 00000000..003f6099
--- /dev/null
+++ b/Medium/Group the People Given the Group Size They Belong To.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public List<List<Integer>> groupThePeople(int[] groupSizes) {
+        Map<Integer, List<List<Integer>>> map = new HashMap<>();
+        int n = groupSizes.length;
+        for (int i = 0; i < n; i++) {
+            int size = groupSizes[i];
+            if (!map.containsKey(size)) {
+                map.put(size, new ArrayList<>());
+                map.get(size).add(new ArrayList<>());
+            }
+            int arraySize = map.get(size).size();
+            if (map.get(size).get(arraySize - 1).size() == size) {
+                map.get(size).add(new ArrayList<>());
+                arraySize++;
+            }
+            map.get(size).get(arraySize - 1).add(i);
+        }
+        List<List<Integer>> ans = new ArrayList<>();
+        for (Integer key : map.keySet()) {
+            List<List<Integer>> lists = map.get(key);
+            for (List<Integer> list : lists) {
+                ans.add(list);
+            }
+        }
+        return ans;
+    }
+}

From c31377e51e0433f53db2a064ec51245599d87906 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 10 Dec 2019 05:51:51 -0800
Subject: [PATCH 0061/2175] Added one solution

---
 Easy/Cells with Odd Values in a Matrix.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Cells with Odd Values in a Matrix.java

diff --git a/Easy/Cells with Odd Values in a Matrix.java b/Easy/Cells with Odd Values in a Matrix.java
new file mode 100644
index 00000000..fbd4b6cb
--- /dev/null
+++ b/Easy/Cells with Odd Values in a Matrix.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int oddCells(int n, int m, int[][] indices) {
+        Map<Integer, Integer> rowMap = new HashMap<>();
+        Map<Integer, Integer> colMap = new HashMap<>();
+        for (int[] indice : indices) {
+            rowMap.put(indice[0], rowMap.getOrDefault(indice[0], 0) + 1);
+            colMap.put(indice[1], colMap.getOrDefault(indice[1], 0) + 1);   
+        }
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                int temp = 0;
+                temp += rowMap.getOrDefault(i, 0);
+                temp += colMap.getOrDefault(j, 0);
+                count += temp % 2;
+            }
+        }
+        return count;
+    }
+}

From 94b5a78b158c9da3debf471509e8823a0a0f1859 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 12 Dec 2019 09:21:38 -0800
Subject: [PATCH 0062/2175] Update Single Element in a Sorted Array.java

---
 Medium/Single Element in a Sorted Array.java | 32 ++++++++++++++------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/Medium/Single Element in a Sorted Array.java b/Medium/Single Element in a Sorted Array.java
index 82edcfee..3565e0b3 100644
--- a/Medium/Single Element in a Sorted Array.java	
+++ b/Medium/Single Element in a Sorted Array.java	
@@ -1,13 +1,25 @@
 class Solution {
-    public int singleNonDuplicate(int[] nums) {
-        boolean evenInd = true;
-        for (int i=0;i<nums.length-1;i++) {
-            if (nums[i] != nums[i+1] && evenInd) {
-                return nums[i];
-            }
-            evenInd = evenInd ? false : true;
-        }
-        
-        return nums[nums.length-1];
+  public int singleNonDuplicate(int[] nums) {
+    if (nums.length == 1) {
+      return nums[0];
     }
+    return binarySearchHelper(nums, 0, nums.length - 1);
+  }
+  
+  private int binarySearchHelper(int[] nums, int start, int end) {
+    if (start > end) {
+      return Integer.MIN_VALUE;
+    }
+    int mid = (start + end) / 2;
+    if (mid == 0 && mid + 1 < nums.length && nums[mid] != nums[mid + 1]) {
+      return nums[mid];
+    }
+    if (mid == nums.length - 1 && mid - 1 >= 0 && nums[mid] != nums[mid - 1]) {
+      return nums[mid];
+    }
+    if (mid + 1 < nums.length && nums[mid] != nums[mid + 1] && mid - 1 >= 0 && nums[mid] != nums[mid - 1]) {
+      return nums[mid];
+    }
+    return Math.max(binarySearchHelper(nums, start, mid - 1), binarySearchHelper(nums, mid + 1, end));
+  }
 }

From cf8dd0db1cda3c771a2478fd8f89e4cc97c9564a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 16 Dec 2019 10:20:48 +0530
Subject: [PATCH 0063/2175] Added 2 solutions

---
 ...ry Number in a Linked List to Integer.java | 29 ++++++++++
 ...pearing More Than 25% In Sorted Array.java | 57 +++++++++++++++++++
 2 files changed, 86 insertions(+)
 create mode 100644 Easy/Convert Binary Number in a Linked List to Integer.java
 create mode 100644 Easy/Element Appearing More Than 25% In Sorted Array.java

diff --git a/Easy/Convert Binary Number in a Linked List to Integer.java b/Easy/Convert Binary Number in a Linked List to Integer.java
new file mode 100644
index 00000000..22ed597d
--- /dev/null
+++ b/Easy/Convert Binary Number in a Linked List to Integer.java	
@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  public int getDecimalValue(ListNode head) {
+    int length = getLength(head);
+    int sum = 0;
+    while (head != null) {
+      sum += ((int) Math.pow(2, length - 1)) * head.val;
+      length--;
+      head = head.next;
+    }
+    return sum;
+  }
+  
+  private int getLength(ListNode head) {
+    int count = 0;
+    while (head != null) {
+      count++;
+      head = head.next;
+    }
+    return count;
+  }
+}
diff --git a/Easy/Element Appearing More Than 25% In Sorted Array.java b/Easy/Element Appearing More Than 25% In Sorted Array.java
new file mode 100644
index 00000000..139c2c07
--- /dev/null
+++ b/Easy/Element Appearing More Than 25% In Sorted Array.java	
@@ -0,0 +1,57 @@
+class Solution {
+  public int findSpecialInteger(int[] arr) {
+    int n = arr.length;
+    int oneFourthNum = arr[n / 4];
+    int halfNum = arr[n / 2];
+    int threeFourthNum = arr[3 * n / 4];
+    if(Math.max(n/4, binarySearchRight(arr, 0, n - 1, oneFourthNum)) - 
+       Math.min(n/4, binarySearchLeft(arr, 0, n - 1, oneFourthNum)) >= arr.length / 4) {
+         return oneFourthNum;
+       }
+    if(Math.max(n/2, binarySearchRight(arr, 0, n - 1, halfNum)) - 
+       Math.min(n/2, binarySearchLeft(arr, 0, n - 1, halfNum)) >= arr.length / 4) {
+         return halfNum;
+       }
+    if(Math.max((3 * n)/4, binarySearchRight(arr, 0, n - 1, threeFourthNum)) - 
+       Math.min((3 * n)/4, binarySearchLeft(arr, 0, n - 1, threeFourthNum)) >= arr.length / 4) {
+         return threeFourthNum;
+       }
+    return -1;
+  }
+  
+  private int binarySearchLeft(int[] arr, int start, int end, int num) {
+    int minIdx = Integer.MAX_VALUE;
+    while (start < end) {
+      int mid = (start + end) / 2;
+      if (arr[mid] == num) {
+        minIdx = Math.min(mid, minIdx);
+        end = mid - 1;
+      }
+      else if (arr[mid] < num) {
+        start = mid + 1;
+      }
+      else {
+        end = mid - 1;
+      }
+    }
+    return minIdx;
+  }
+  
+  private int binarySearchRight(int[] arr, int start, int end, int num) {
+    int maxIdx = Integer.MIN_VALUE;
+    while (start < end) {
+      int mid = (start + end) / 2;
+      if (arr[mid] == num) {
+        maxIdx = Math.max(mid, maxIdx);
+        start = mid + 1;
+      }
+      else if (arr[mid] < num) {
+        start = mid + 1;
+      }
+      else {
+        end = mid - 1;
+      }
+    }
+    return maxIdx;
+  }
+}

From 18db5e4ff05fafac6d91b10287ef7bfd5ab10b8d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 17 Dec 2019 06:33:13 +0530
Subject: [PATCH 0064/2175] Added Print Immutable Linked List in Reverse.java

---
 Easy/Occurrences After Bigram.java            | 25 ++++------
 ...rint Immutable Linked List in Reverse.java | 50 +++++++++++++++++++
 2 files changed, 59 insertions(+), 16 deletions(-)
 create mode 100644 Medium/Print Immutable Linked List in Reverse.java

diff --git a/Easy/Occurrences After Bigram.java b/Easy/Occurrences After Bigram.java
index 57ca1d18..4476bfaf 100644
--- a/Easy/Occurrences After Bigram.java	
+++ b/Easy/Occurrences After Bigram.java	
@@ -1,19 +1,12 @@
 class Solution {
-    public String[] findOcurrences(String text, String first, String second) {
-        String[] words = text.split("\\s+");
-        List<Integer> indexes = new ArrayList<>();
-        
-        for (int i = 0; i < words.length - 2; i++) {
-            if (words[i].equals(first) && words[i + 1].equals(second)) {
-                indexes.add(i + 2);
-            }
-        }
-        
-        String[] ans = new String[indexes.size()];
-        for (int i = 0; i < indexes.size(); i++) {
-            ans[i] = words[indexes.get(i)];
-        }
-        
-        return ans;
+  public String[] findOcurrences(String text, String first, String second) {
+    String[] words = text.split("\\s+"); 
+    List<String> list = new ArrayList<>();
+    for (int i = 0; i < words.length - 2; i++) {
+      if (words[i].equals(first) && words[i + 1].equals(second)) {
+        list.add(words[i + 2]);
+      }
     }
+    return list.toArray(new String[list.size()]);
+  }
 }
diff --git a/Medium/Print Immutable Linked List in Reverse.java b/Medium/Print Immutable Linked List in Reverse.java
new file mode 100644
index 00000000..17a3be68
--- /dev/null
+++ b/Medium/Print Immutable Linked List in Reverse.java	
@@ -0,0 +1,50 @@
+/**
+ * // This is the ImmutableListNode's API interface.
+ * // You should not implement it, or speculate about its implementation.
+ * interface ImmutableListNode {
+ *     public void printValue(); // print the value of this node.
+ *     public ImmutableListNode getNext(); // return the next node.
+ * };
+ */
+
+class Solution {
+  Stack<ImmutableListNode> stack;
+  ImmutableListNode lastPopped;
+  public void printLinkedListInReverse(ImmutableListNode head) {
+    stack = new Stack<>();
+    lastPopped = null;
+    int lengthSquareRoot = (int) Math.log(getLength(head));
+    ImmutableListNode curr = head;
+    int count = 0;
+    while (curr != null) {
+      if (count % lengthSquareRoot == 0) {
+        stack.push(curr);
+      }
+      curr = curr.getNext();
+      count++;
+    }
+    while (!stack.isEmpty()) {
+      ImmutableListNode popped = stack.pop();
+      printNode(popped);
+      lastPopped = popped;
+    }
+  }
+  
+  private void printNode(ImmutableListNode node) {
+    if (node == lastPopped) {
+      return;
+    }
+    printNode(node.getNext());
+    node.printValue();
+  }
+  
+  private int getLength(ImmutableListNode node) {
+    int count = 0;
+    while (node != null) {
+      node = node.getNext();
+      count++;
+    }
+    return count;
+  }
+}
+

From 3dfcc57d8306b20aecd429d71654678c3329f2ee Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 18 Dec 2019 09:02:20 +0530
Subject: [PATCH 0065/2175] Refactored 3 solutions

---
 .../Binary Tree Level Order Traversal II.java |  41 ++++---
 .../All Nodes Distance K in Binary Tree.java  | 103 +++++++++---------
 Medium/Encode and Decode Strings.java         |  49 +++++----
 3 files changed, 101 insertions(+), 92 deletions(-)

diff --git a/Easy/Binary Tree Level Order Traversal II.java b/Easy/Binary Tree Level Order Traversal II.java
index 80efe5aa..3abbbb30 100644
--- a/Easy/Binary Tree Level Order Traversal II.java	
+++ b/Easy/Binary Tree Level Order Traversal II.java	
@@ -8,24 +8,29 @@
  * }
  */
 class Solution {
-    public List<List<Integer>> levelOrderBottom(TreeNode root) {
-        List<List<Integer>> ans = new ArrayList<>();
-        if(root == null) return ans;
-        Queue<TreeNode> q = new LinkedList<>();
-        q.add(root);
-        
-        while(q.size()>0) {
-            List<Integer> arr = new ArrayList<>();
-            int size = q.size();
-            for (int i=0;i<size;i++) {
-                TreeNode n = q.poll();
-                arr.add(n.val);
-                if(n.left != null) q.add(n.left);
-                if(n.right != null) q.add(n.right);
-            }
-            ans.add(0, arr);
+  public List<List<Integer>> levelOrderBottom(TreeNode root) {
+    List<List<Integer>> list = new ArrayList<>();
+    if (root == null) {
+      return list;
+    }
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      List<Integer> temp = new ArrayList<>();
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        temp.add(removed.val);
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
         }
-        
-        return ans;
+      }
+      list.add(temp);
     }
+    Collections.reverse(list);
+    return list;
+  }
 }
diff --git a/Medium/All Nodes Distance K in Binary Tree.java b/Medium/All Nodes Distance K in Binary Tree.java
index f00bad4a..4c2ac67d 100644
--- a/Medium/All Nodes Distance K in Binary Tree.java	
+++ b/Medium/All Nodes Distance K in Binary Tree.java	
@@ -8,58 +8,61 @@
  * }
  */
 class Solution {
-    
-    public Map<TreeNode, TreeNode> parentMap;
-    public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
-        parentMap = new HashMap<>();
-        addParentHelper(root, null);
-        
-        Set<TreeNode> visited = new HashSet<>();
-        Queue<TreeNode> queue = new LinkedList<>();
-        int currLevel = 0;
-        
-        queue.add(target);
-        
-        while (!queue.isEmpty() && currLevel != K) {
-            int size = queue.size();
-            
-            while (size-- > 0) {
-                TreeNode removed = queue.remove();
-                visited.add(removed);
-                TreeNode parent = parentMap.get(removed);
-                
-                if (removed.left != null && !visited.contains(removed.left)) {
-                    queue.add(removed.left);
-                }
-                
-                if (removed.right != null && !visited.contains(removed.right)) {
-                    queue.add(removed.right);
-                }
-                
-                if (parent != null && !visited.contains(parent)) {
-                    queue.add(parent);
-                }
-            }
-            
-            currLevel++;
+  List<Integer> list;
+  TreeNode target;
+  int K;
+  public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
+    list = new ArrayList<>();
+    this.target = target;
+    this.K = K;
+    dfs(root);
+    return list;
+  }
+
+  private int dfs(TreeNode node) {
+    if (node == null) {
+      return -1;
+    }
+    else if (node == target) {
+      subtreeDfs(node, 0);
+      return 1;
+    }
+    else {
+      int L = dfs(node.left);
+      int R = -1;
+      if (L != -1) {
+        if (L == K) {
+          list.add(node.val);
         }
-        
-        List<Integer> list = new ArrayList<>();
-        while (!queue.isEmpty()) {
-            list.add(queue.remove().val);
+        subtreeDfs(node.right, L + 1);
+        return L + 1;
+      }
+      else if ((R = dfs(node.right)) != -1) {
+        if (R == K) {
+          list.add(node.val);
         }
-        
-        return list;
+        subtreeDfs(node.left, R + 1);
+        return R + 1;
+      }
+      else {
+        return -1;
+      }
     }
-    
-    private void addParentHelper(TreeNode node, TreeNode parent) {
-        if (node == null) {
-            return;
-        }
-        
-        parentMap.put(node, parent);
-        
-        addParentHelper(node.left, node);
-        addParentHelper(node.right, node);
+  }
+  
+  private void subtreeDfs(TreeNode node, int dist) {
+    if (node == null) {
+      return;
+    }
+    if (dist == K) {
+      list.add(node.val);
+    }
+    else if (dist > K) {
+      return;
+    }
+    else {
+      subtreeDfs(node.left, dist + 1);
+      subtreeDfs(node.right, dist + 1);
     }
+  }
 }
diff --git a/Medium/Encode and Decode Strings.java b/Medium/Encode and Decode Strings.java
index cbdce47e..ec923b8f 100644
--- a/Medium/Encode and Decode Strings.java	
+++ b/Medium/Encode and Decode Strings.java	
@@ -1,34 +1,35 @@
 public class Codec {
 
-    // Encodes a list of strings to a single string.
-    public String encode(List<String> strs) {
-        StringBuilder sb = new StringBuilder("");
-        
-        for (String str : strs) {
-            sb.append(str.length()).append("|").append(str);
-        }
-        
-        return sb.toString();
+  // Encodes a list of strings to a single string.
+  public String encode(List<String> strs) {
+    StringBuilder sb = new StringBuilder();
+    for (String str : strs) {
+      sb.append(lengthEncode(str)).append(str);
     }
+    return sb.toString();
+  }
 
-    // Decodes a single string to a list of strings.
-    public List<String> decode(String s) {
-        List<String> list = new ArrayList<>();
-        
-        int idx = 0;
-        int n = s.length();
-        
-        while (idx < n) {
-            int slashIdx = s.indexOf('|', idx);
-            int size = Integer.parseInt(s.substring(idx, slashIdx));
-            idx = slashIdx + size + 1;
-            list.add(s.substring(slashIdx + 1, idx));
-        }
-        
-        return list;
+  // Decodes a single string to a list of strings.
+  public List<String> decode(String s) {
+    int idx = 0;
+    int n = s.length();
+    List<String> list = new ArrayList<>();
+    while (idx < n) {
+      int length = Integer.parseInt(s.substring(idx, idx + 10));
+      idx += 10;
+      list.add(s.substring(idx, idx + length));
+      idx += length;
     }
+    return list;
+  }
+  
+  private String lengthEncode(String s) {
+    int n = s.length();
+    return String.join("", Collections.nCopies(10 - String.valueOf(n).length(), "0")) + String.valueOf(n);
+  }
 }
 
 // Your Codec object will be instantiated and called as such:
 // Codec codec = new Codec();
 // codec.decode(codec.encode(strs));
+

From c6a4243757238375d3fe8812dff679f03efb5d0d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 19 Dec 2019 07:05:07 +0530
Subject: [PATCH 0066/2175] Added Minimum Height Trees.java

---
 Medium/Find the Celebrity.java   | 39 ++++++++----------------
 Medium/Graph Valid Tree.java     | 51 ++++++++++++++++----------------
 Medium/Minimum Height Trees.java | 34 +++++++++++++++++++++
 3 files changed, 73 insertions(+), 51 deletions(-)
 create mode 100644 Medium/Minimum Height Trees.java

diff --git a/Medium/Find the Celebrity.java b/Medium/Find the Celebrity.java
index 02dcbb84..ee2fd524 100644
--- a/Medium/Find the Celebrity.java	
+++ b/Medium/Find the Celebrity.java	
@@ -2,31 +2,18 @@
       boolean knows(int a, int b); */
 
 public class Solution extends Relation {
-    public int findCelebrity(int n) {
-        Stack<Integer> stack = new Stack<>();
-        for (int i=0; i<n; i++) {
-            stack.push(i);
-        }
-
-        while (stack.size() > 1) {
-            int person1 = stack.pop();
-            int person2 = stack.pop();
-
-            if (knows(person1, person2)) {
-                stack.push(person2);
-            }
-            else {
-                stack.push(person1);
-            }
-        }
-        
-        int person = stack.pop();
-        for (int i=0; i<n; i++) {
-            if (i != person && (knows(person, i) || !knows(i, person))) {
-                return -1;
-            }
-        }
-        
-        return person;
+  public int findCelebrity(int n) {
+    int suspectedCelebrity = 0;
+    for (int i = 1; i < n; i++) {
+      if (knows(suspectedCelebrity, i)) {
+        suspectedCelebrity = i;
+      }
+    }
+    for (int i = 0; i < n; i++) { 
+      if (i != suspectedCelebrity && (knows(suspectedCelebrity, i) || !knows(i, suspectedCelebrity))) {
+        return -1;
+      }
     }
+    return suspectedCelebrity;
+  }
 }
diff --git a/Medium/Graph Valid Tree.java b/Medium/Graph Valid Tree.java
index ded57df9..7b35c66f 100644
--- a/Medium/Graph Valid Tree.java	
+++ b/Medium/Graph Valid Tree.java	
@@ -1,31 +1,32 @@
 class Solution {
-    public boolean validTree(int n, int[][] edges) {
-        if (edges.length != n - 1) {
-            return false;
+  public boolean validTree(int n, int[][] edges) {
+    Map<Integer, Set<Integer>> map = new HashMap<>();
+    for (int[] edge : edges) {
+      map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+      map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+    }
+    Queue<Integer> queue = new LinkedList<>();
+    int[] visited = new int[n];
+    queue.add(0);
+    visited[0] = 1;
+    while (!queue.isEmpty()) {
+      Integer removed = queue.remove();
+      for (Integer connection : map.getOrDefault(removed, new HashSet<>())) {
+        if (visited[connection] == 1) {
+          return false;
         }
-        
-        int[] points = new int[n];
-        Arrays.fill(points, -1);
-        
-        for (int[] edge : edges) {
-            int parentPoint = getPosition(points, edge[0]);
-            int childPoint = getPosition(points, edge[1]);
-            
-            if (parentPoint == childPoint) {
-                return false;
-            }
-            
-            points[parentPoint] = childPoint;
+        if (visited[connection] == 0) {
+          visited[connection] = 1;
+          queue.add(connection);
         }
-        
-        return true;
+      }
+      visited[removed] = 2;
     }
-    
-    private int getPosition(int[] points, int num) {
-        if (points[num] == -1) {
-            return num;
-        }
-        
-        return getPosition(points, points[num]);
+    for (int node : visited) {
+      if (node == 0) {
+        return false;
+      }
     }
+    return true;
+  }
 }
diff --git a/Medium/Minimum Height Trees.java b/Medium/Minimum Height Trees.java
new file mode 100644
index 00000000..8bf0e21f
--- /dev/null
+++ b/Medium/Minimum Height Trees.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public List<Integer> findMinHeightTrees(int n, int[][] edges) {
+    if (n == 1) {
+      return Collections.singletonList(0);
+    }
+    Map<Integer, Set<Integer>> map = new HashMap<>();
+    for (int[] edge: edges) {
+      map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+      map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    }
+    List<Integer> leaves = new ArrayList<>();
+    for (int i = 0; i < n; i++) {
+      if (map.getOrDefault(i, new HashSet<>()).size() == 1) {
+        leaves.add(i);
+      }
+    }
+    int count = n;
+    while (count > 2) {
+      int size = leaves.size();
+      count -= size;
+      List<Integer> newLeaves = new ArrayList<>();
+      for (int leaf : leaves) {
+        for (int toRemove : map.getOrDefault(leaf, new HashSet<>())) {
+          map.get(toRemove).remove(leaf);
+          if (map.get(toRemove).size() == 1) {
+            newLeaves.add(toRemove);
+          }
+        }
+      }
+      leaves = newLeaves;
+    }
+    return leaves;
+  }
+}

From 1b13a383361a34d3d0259e9094faeb1114791a4b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 20 Dec 2019 06:26:19 +0530
Subject: [PATCH 0067/2175] Added Teoplitz Matrix.java & refactored 4 solutions

---
 Easy/Teoplitz Matrix.java                     | 12 +++++
 ...ng with At Most K Distinct Characters.java | 38 +++++++-------
 ...inary Search Tree to Greater Sum Tree.java | 35 ++++++++-----
 Medium/Max Increase to Keep City Skyline.java | 45 ++++++-----------
 Medium/Sort Characters By Frequency.java      | 49 +++++++------------
 5 files changed, 84 insertions(+), 95 deletions(-)
 create mode 100644 Easy/Teoplitz Matrix.java

diff --git a/Easy/Teoplitz Matrix.java b/Easy/Teoplitz Matrix.java
new file mode 100644
index 00000000..97bbc287
--- /dev/null
+++ b/Easy/Teoplitz Matrix.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public boolean isToeplitzMatrix(int[][] matrix) {
+    for (int i = 0; i < matrix.length; i++) {
+      for (int j = 0; j < matrix[0].length; j++) {
+        if (i > 0 && j > 0 && matrix[i][j] != matrix[i - 1][j - 1]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+}
diff --git a/Hard/Longest Substring with At Most K Distinct Characters.java b/Hard/Longest Substring with At Most K Distinct Characters.java
index 4e524cfd..ae6a1c78 100644
--- a/Hard/Longest Substring with At Most K Distinct Characters.java	
+++ b/Hard/Longest Substring with At Most K Distinct Characters.java	
@@ -1,24 +1,22 @@
 class Solution {
-    public int lengthOfLongestSubstringKDistinct(String s, int k) {
-        int maxLen = 0;
-        int start = 0;
-        
-        Map<Character, Integer> map = new HashMap<>();
-        for (int i = 0; i < s.length(); i++) {
-            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
-            
-            while (map.size() > k) {
-                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
-                if (map.get(s.charAt(start)) == 0) {
-                    map.remove(s.charAt(start));
-                }
-                
-                start++;
-            }
-            
-            maxLen = Math.max(maxLen, i - start + 1);
+  public int lengthOfLongestSubstringKDistinct(String s, int k) {
+    Map<Character, Integer> map = new HashMap<>();
+    int slow = 0;
+    int fast = 0;
+    int n = s.length();
+    int maxLength = 0;
+    while (fast < n) {
+      map.put(s.charAt(fast), map.getOrDefault(s.charAt(fast), 0) + 1);
+      while (map.size() > k) {
+        map.put(s.charAt(slow), map.getOrDefault(s.charAt(slow), 0) - 1);
+        if (map.get(s.charAt(slow)) == 0) {
+          map.remove(s.charAt(slow));
         }
-        
-        return maxLen;
+        slow++;
+      }
+      fast++;
+      maxLength = Math.max(maxLength, fast - slow);
     }
+    return maxLength;
+  }
 }
diff --git a/Medium/Binary Search Tree to Greater Sum Tree.java b/Medium/Binary Search Tree to Greater Sum Tree.java
index af760c96..91c63aa7 100644
--- a/Medium/Binary Search Tree to Greater Sum Tree.java	
+++ b/Medium/Binary Search Tree to Greater Sum Tree.java	
@@ -8,19 +8,28 @@
  * }
  */
 class Solution {
-    public TreeNode bstToGst(TreeNode root) {
-        inorderReverse(root, new int[]{0});
-        return root;
+  public TreeNode bstToGst(TreeNode root) {
+    if (root == null) {
+      return null;
     }
-    
-    private void inorderReverse(TreeNode root, int[] currVal) {
-        if (root == null) {
-            return;
-        }
-        
-        inorderReverse(root.right, currVal);
-        currVal[0] += root.val;
-        root.val = currVal[0];
-        inorderReverse(root.left, currVal);
+    TreeNode curr = root;
+    Stack<TreeNode> stack = new Stack<>();
+    int sum = 0;
+    pushRight(stack, curr);
+    while (!stack.isEmpty()) {
+      TreeNode removed = stack.pop();
+      sum += removed.val;
+      removed.val = sum;
+      TreeNode leftNode = removed.left;
+      pushRight(stack, leftNode);
     }
+    return root;
+  }
+  
+  private void pushRight(Stack<TreeNode> stack, TreeNode curr) {
+    while (curr != null) {
+      stack.push(curr);
+      curr = curr.right;
+    }
+  }
 }
diff --git a/Medium/Max Increase to Keep City Skyline.java b/Medium/Max Increase to Keep City Skyline.java
index 3e4a7f0b..fbcc1f27 100644
--- a/Medium/Max Increase to Keep City Skyline.java	
+++ b/Medium/Max Increase to Keep City Skyline.java	
@@ -1,36 +1,21 @@
 class Solution {
     public int maxIncreaseKeepingSkyline(int[][] grid) {
-        int[] top = new int[grid.length];
-        int[] left = new int[grid.length];
-        int j = 0;
-
-        for (int[] g : grid) {
-            int max = Integer.MIN_VALUE;
-            for (int i=0; i<g.length; i++) {
-                max = Math.max(max, g[i]);
-            }
-
-            left[j++] = max;
+      int numRows = grid.length;
+      int numCols = grid[0].length;
+      int[] rowMax = new int[numRows];
+      int[] colMax = new int[numCols];
+      for (int i = 0; i < numRows; i++) {
+        for (int j = 0; j < numCols; j++) {
+          rowMax[i] = Math.max(rowMax[i], grid[i][j]);
+          colMax[j] = Math.max(colMax[j], grid[i][j]);
         }
-
-        j = 0;
-        for (int i=0; i<grid.length; i++) {
-            int max = Integer.MIN_VALUE;
-            for (int k=0; k<grid.length; k++) {
-                max = Math.max(grid[k][i], max);
-            }
-
-            top[j++] = max;
+      }    
+      int totalIncrease = 0;
+      for (int i = 0; i < numRows; i++) {
+        for (int j = 0; j < numCols; j++) {
+          totalIncrease += Math.min(rowMax[i], colMax[j]) - grid[i][j];
         }
-        
-        int increase = 0;
-
-        for (int i=0; i<grid.length; i++) {
-            for (int k=0; k<grid[0].length; k++) {
-                increase += Math.min(left[i], top[k]) - grid[i][k];
-            }
-        }
-        
-        return increase;
+      }
+      return totalIncrease;
     }
 }
diff --git a/Medium/Sort Characters By Frequency.java b/Medium/Sort Characters By Frequency.java
index 134f437b..4d0ed2b2 100644
--- a/Medium/Sort Characters By Frequency.java	
+++ b/Medium/Sort Characters By Frequency.java	
@@ -1,35 +1,20 @@
 class Solution {
-    public String frequencySort(String s) {
-        List<Character> chars = new ArrayList<>();
-        for (char c : s.toCharArray()) {
-            chars.add(c);
-        }
-
-        Map<Character, Integer> map = new HashMap<>();
-        int val = 0;
-        for (char c : chars) {
-            map.put(c, map.getOrDefault(c, 0) + 1);
-            val = Math.max(val, map.get(c));
-        }
-
-        Map<Integer, List<Character>> revMap = new HashMap<>();
-        for (Character key : map.keySet()) {
-            revMap.computeIfAbsent(map.get(key), k -> new ArrayList<>()).add(key);
-        }
-
-        StringBuilder sb = new StringBuilder();
-        for (int i = val; i >= 0; i--) {
-            if (revMap.containsKey(i)) {
-                List<Character> characters = revMap.get(i);
-                for (Character character : characters) {
-                    int count = i;
-                    while (count-- > 0) {
-                        sb.append(character);
-                    }
-                }
-            }
-        }
-
-        return sb.toString();
+  public String frequencySort(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      map.put(c, map.getOrDefault(c, 0) + 1);
+    }
+    PriorityQueue<Character> pq = new PriorityQueue<>((o1, o2) -> map.get(o2) - map.get(o1));
+    pq.addAll(map.keySet());
+    StringBuilder sb = new StringBuilder();
+    while (!pq.isEmpty()) {
+      char c = pq.poll();
+      int count  = map.get(c);
+      while (count-- > 0) {
+        sb.append(c);
+      }
     }
+    return sb.toString();
+  }
 }
+

From 28fa28772e98a6668069d09d2a3d783098b0a0c4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 21 Dec 2019 06:44:09 +0530
Subject: [PATCH 0068/2175] Added 1 solution & refactored 2 solutions

---
 ...tring with Concatenation of All Words.java | 74 +++++++++----------
 ...y Search Tree from Preorder Traversal.java | 28 +++++++
 Medium/Maximum Binary Tree.java               | 54 +++++++-------
 3 files changed, 93 insertions(+), 63 deletions(-)
 create mode 100644 Medium/Construct Binary Search Tree from Preorder Traversal.java

diff --git a/Hard/Substring with Concatenation of All Words.java b/Hard/Substring with Concatenation of All Words.java
index 95cf6132..1af85664 100644
--- a/Hard/Substring with Concatenation of All Words.java	
+++ b/Hard/Substring with Concatenation of All Words.java	
@@ -1,41 +1,39 @@
 class Solution {
-    public List<Integer> findSubstring(String s, String[] words) {
-        List<Integer> indexes = new ArrayList<>();
-        if (words.length == 0) {
-            return indexes;
-        }
-        
-        Map<String, Integer> freqMap = new HashMap<>();
-        for (String word : words) {
-            freqMap.put(word, freqMap.getOrDefault(word, 0) + 1);
-        }
-        
-        int start = 0;
-        int oneWordLen = words[0].length();
-        int totalLen = oneWordLen * words.length;
-        
-        while ((s.length() - start) >= totalLen) {
-            String subStr = s.substring(start, start + totalLen);
-            int i = 0;
-            Map<String, Integer> map = new HashMap<>(freqMap);
-            while (i < subStr.length()) {
-                String wordStr = subStr.substring(i, i + oneWordLen);
-                
-                if (!map.containsKey(wordStr) || map.get(wordStr) < 1) {
-                    break;
-                }
-                
-                map.put(wordStr, map.get(wordStr) - 1);
-                i += oneWordLen;
-            }
-            
-            if (i >= subStr.length()) {
-                indexes.add(start);
-            }
-            
-            start++;
-        }
-        
-        return indexes;
+  public List<Integer> findSubstring(String s, String[] words) {
+    if (s.length() == 0 || words.length == 0) {
+      return new ArrayList<>();
     }
+    Map<String, Integer> wordFreqMap = new HashMap<>();
+    for (String word : words) {
+      wordFreqMap.put(word, wordFreqMap.getOrDefault(word, 0) + 1);
+    }
+    int stringLength = s.length();
+    int wordCount = words.length;
+    int singleWordLength = words[0].length();
+    List<Integer> indices = new ArrayList<>();
+    for (int i = 0; i + singleWordLength * wordCount <= stringLength; i++) {
+      if (match(s, i, singleWordLength, wordFreqMap, wordCount)) {
+        indices.add(i);
+      }
+    }
+    return indices;
+  }
+  
+  private boolean match(String s, int start, int singleWordLength, Map<String, Integer> wordFreqMap, int wordCount) {
+    Map<String, Integer> currFreqMap = new HashMap<>();
+    for (int i = 0; i < wordCount; i++) {
+      String currWord = s.substring(start + i * singleWordLength, start + (i + 1) * singleWordLength);
+      Integer freq = wordFreqMap.get(currWord);
+      // Word not in required words
+      if (freq == null) { 
+        return false;
+      }
+      currFreqMap.put(currWord, currFreqMap.getOrDefault(currWord, 0) + 1);
+      // Word occurs more than the required count
+      if (currFreqMap.get(currWord) > freq) {
+        return false;
+      }
+    }
+    return true;
+  }
 }
diff --git a/Medium/Construct Binary Search Tree from Preorder Traversal.java b/Medium/Construct Binary Search Tree from Preorder Traversal.java
new file mode 100644
index 00000000..9361c50c
--- /dev/null
+++ b/Medium/Construct Binary Search Tree from Preorder Traversal.java	
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  int idx;
+  public TreeNode bstFromPreorder(int[] preorder) {
+    idx = 0;
+    return helper(preorder, Integer.MIN_VALUE, Integer.MAX_VALUE);
+  }
+  
+  private TreeNode helper(int[] preorder, int lower, int upper) {
+    if (idx == preorder.length || preorder[idx] < lower || preorder[idx] > upper) {
+      return null;
+    }
+    int val = preorder[idx];
+    idx++;
+    TreeNode root = new TreeNode(val);
+    root.left = helper(preorder, lower, val);
+    root.right = helper(preorder, val, upper);
+    return root;
+  }
+}
diff --git a/Medium/Maximum Binary Tree.java b/Medium/Maximum Binary Tree.java
index 93d7ac55..03cda51a 100644
--- a/Medium/Maximum Binary Tree.java	
+++ b/Medium/Maximum Binary Tree.java	
@@ -8,31 +8,35 @@
  * }
  */
 class Solution {
-    public TreeNode constructMaximumBinaryTree(int[] nums) {
-        if (nums.length == 0) {
-            return null;
-        }
-        
-        return constructTree(nums, 0, nums.length-1);
+  public TreeNode constructMaximumBinaryTree(int[] nums) {
+    if (nums.length == 0) {
+      return null;
     }
-    
-    private TreeNode constructTree(int[] nums, int start, int end) {
-        if (start > end) {
-            return null;
-        }
-        
-        int idx = start;
-        for (int i=start+1; i<=end; i++) {
-            if (nums[i] > nums[idx]) {
-                idx = i;
-            }
-        }
-        
-        TreeNode root = new TreeNode(nums[idx]);
-        
-        root.left = constructTree(nums, start, idx-1);
-        root.right = constructTree(nums, idx+1, end);
-        
-        return root;
+    TreeNode root = helper(nums, 0, nums.length - 1);
+    return root;
+  }
+  
+  private TreeNode helper(int[] nums, int start, int end) {
+    if (start > end) {
+      return null;
     }
+    int maxIdx = getMaxIdx(nums, start, end);
+    TreeNode root = new TreeNode(nums[maxIdx]);
+    root.left = helper(nums, start, maxIdx - 1);
+    root.right = helper(nums, maxIdx + 1, end);
+    return root;
+  }
+  
+  private int getMaxIdx(int[] nums, int start, int end) {
+    int maxVal = Integer.MIN_VALUE;
+    int maxIdx = -1;
+    while (start <= end) {
+      if (nums[start] > maxVal) {
+        maxVal = nums[start];
+        maxIdx = start;
+      }
+      start++;
+    }
+    return maxIdx;
+  }
 }

From e95d5d0d4c822408da44cbd19c48f5f96f87ee37 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 22 Dec 2019 12:17:35 +0530
Subject: [PATCH 0069/2175] Added 3 solutions

---
 ...nd Numbers with Even Number of Digits.java |  9 ++++++
 ...rray in Sets of K Consecutive Numbers.java | 32 +++++++++++++++++++
 ...d Smallest Common Element in All Rows.java | 16 ++++++++++
 3 files changed, 57 insertions(+)
 create mode 100644 Easy/Find Numbers with Even Number of Digits.java
 create mode 100644 Medium/Divide Array in Sets of K Consecutive Numbers.java
 create mode 100644 Medium/Find Smallest Common Element in All Rows.java

diff --git a/Easy/Find Numbers with Even Number of Digits.java b/Easy/Find Numbers with Even Number of Digits.java
new file mode 100644
index 00000000..961f9ec5
--- /dev/null
+++ b/Easy/Find Numbers with Even Number of Digits.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public int findNumbers(int[] nums) {
+    int count = 0;
+    for (int num : nums) {
+      count += String.valueOf(num).length() % 2 == 0 ? 1 : 0;
+    }
+    return count;
+  }
+}
diff --git a/Medium/Divide Array in Sets of K Consecutive Numbers.java b/Medium/Divide Array in Sets of K Consecutive Numbers.java
new file mode 100644
index 00000000..31edb48b
--- /dev/null
+++ b/Medium/Divide Array in Sets of K Consecutive Numbers.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public boolean isPossibleDivide(int[] nums, int k) {
+    if (nums.length % k != 0) {
+      return false;
+    }
+    int n = nums.length;
+    int numOfGroups = n / k;
+    Map<Integer, Integer> map = new HashMap<>();
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    pq.addAll(map.keySet());
+    while (!pq.isEmpty()) {
+      int polled = pq.poll();
+      if (map.get(polled) == 0) {
+        continue;
+      }
+      int times = map.get(polled);
+      while (times-- > 0) {
+        for (int i = 0; i < k; i++) {
+          if (!map.containsKey(polled + i) || map.get(polled + i) == 0) {
+            return false;
+          }
+          map.put(polled + i, map.get(polled + i) - 1);
+        }
+        n -= k;
+      }
+    }
+    return n == 0;
+  }
+}
diff --git a/Medium/Find Smallest Common Element in All Rows.java b/Medium/Find Smallest Common Element in All Rows.java
new file mode 100644
index 00000000..120a3900
--- /dev/null
+++ b/Medium/Find Smallest Common Element in All Rows.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int smallestCommonElement(int[][] mat) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int numRows = mat.length;
+    int numCols = mat[0].length;
+    for (int i = 0; i < numCols; i++) {
+      for (int j = 0; j < numRows; j++) {
+        map.put(mat[j][i], map.getOrDefault(mat[j][i], 0) + 1);
+        if (map.get(mat[j][i]) == numRows) {
+          return mat[j][i];
+        }
+      }
+    }
+    return -1;
+  }
+}

From e1451006bb782c1a703bee92dd19057c27e9b573 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 23 Dec 2019 07:42:36 +0530
Subject: [PATCH 0070/2175] Added Sequential Digits.java & modified 2 solutions

---
 Easy/Rotting Oranges.java     | 75 +++++++++++++++--------------------
 Medium/Sequential Digits.java | 18 +++++++++
 Medium/Summary Ranges.java    | 57 +++++++-------------------
 3 files changed, 66 insertions(+), 84 deletions(-)
 create mode 100644 Medium/Sequential Digits.java

diff --git a/Easy/Rotting Oranges.java b/Easy/Rotting Oranges.java
index fde319fb..a4eb051f 100644
--- a/Easy/Rotting Oranges.java	
+++ b/Easy/Rotting Oranges.java	
@@ -1,48 +1,39 @@
 class Solution {
-    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-    public int orangesRotting(int[][] grid) {
-        Queue<Integer> queue = new LinkedList<>();
-        Map<Integer, Integer> map = new HashMap<>();
-        int numRows = grid.length;
-        int numCols = grid[0].length;
-
-        for (int i = 0; i < numRows; i++) {
-            for (int j = 0; j < numCols; j++) {
-                if (grid[i][j] == 2) {
-                    int key = numCols * i + j;
-                    queue.add(key);
-                    map.put(key, 0);
-                }
-            }
+  int[][] dirs = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
+  public final int VISITED = -1;
+  public int orangesRotting(int[][] grid) {
+    int minutes = 0;
+    Queue<int[]> queue = new LinkedList<>();
+    for (int i = 0; i < grid.length; i++) {
+      for (int j = 0; j < grid[i].length; j++) {
+        if (grid[i][j] == 2) {
+          queue.add(new int[]{i, j});
         }
-
-        int ans = 0;
-        while (!queue.isEmpty()) {
-            int key = queue.remove();
-            int x = key / numCols;
-            int y = key % numCols;
-            for (int[] dir : dirs) {
-                int newX = x + dir[0];
-                int newY = y + dir[1];
-                if (newX < 0 || newX >= numRows || newY < 0 || newY >= numCols || grid[newX][newY] != 1) {
-                    continue;
-                }
-                grid[newX][newY] = 2;
-                int newKey = newX * numCols + newY;
-                queue.add(newKey);
-                map.put(newKey, map.get(key) + 1);
-                ans = map.get(newKey);
-            }
+      }
+    }
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int[] removed = queue.remove();
+        for (int[] dir : dirs) {
+          int newX = removed[0] + dir[0];
+          int newY = removed[1] + dir[1];
+          if (newX >= 0 && newX < grid.length && newY >= 0 && newY < grid[0].length && grid[newX][newY] == 1) {
+            grid[newX][newY] = 2;
+            queue.add(new int[]{newX, newY});
+          }
         }
-
-        for (int i = 0; i < numRows; i++) {
-            for (int j = 0; j < numCols; j++) {
-                if (grid[i][j] == 1) {
-                    return -1;
-                }
-            }
+        grid[removed[0]][removed[1]] = VISITED;
+      }
+      minutes++;
+    }
+    for (int i = 0; i < grid.length; i++) {
+      for (int j = 0; j < grid[i].length; j++) {
+        if (grid[i][j] == 1) {
+          return -1;
         }
-
-        return ans;
+      }
     }
+    return minutes > 0 ? minutes - 1 : 0;
+  }
 }
diff --git a/Medium/Sequential Digits.java b/Medium/Sequential Digits.java
new file mode 100644
index 00000000..ab52770d
--- /dev/null
+++ b/Medium/Sequential Digits.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public List<Integer> sequentialDigits(int low, int high) {
+    String bucket = "123456789";
+    int n = 10;
+    List<Integer> list = new ArrayList<>();
+    int lowLength = String.valueOf(low).length();
+    int highLength = String.valueOf(high).length();
+    for (int length = lowLength; length < highLength + 1; length++) {
+      for (int start = 0; start < n - length; start++) {
+        int num = Integer.parseInt(bucket.substring(start, start + length));
+        if (num >= low && num <= high) {
+          list.add(num);
+        }
+      }
+    }
+    return list;
+  }
+}
diff --git a/Medium/Summary Ranges.java b/Medium/Summary Ranges.java
index 8964bcef..340b0f30 100644
--- a/Medium/Summary Ranges.java	
+++ b/Medium/Summary Ranges.java	
@@ -1,45 +1,18 @@
 class Solution {
-    public List<String> summaryRanges(int[] nums) {
-        List<String> ranges = new ArrayList<>();
-
-        if (nums.length == 0) {
-            return ranges;
-        }
-
-        int count = 1;
-        int i = 0;
-        StringBuilder sb = new StringBuilder();
-        sb.append(nums[0]);
-        int n = nums.length-1;
-
-        while (i < n) {
-            if (nums[i+1] - nums[i] == 1) {
-                count++;
-            }
-            else {
-                if (count > 1) {
-                    sb.append("->").append(nums[i]);
-                    ranges.add(sb.toString());
-                    count = 1;
-                }
-                else {
-                    ranges.add(sb.toString());
-                }
-                sb = new StringBuilder();
-                sb.append(nums[i+1]);
-            }
-
-            i++;
-        }
-
-        if (count > 1) {
-            sb.append("->").append(nums[i]);
-            ranges.add(sb.toString());
-        }
-        else {
-            ranges.add(sb.toString());
-        }
-
-        return ranges;
+  public List<String> summaryRanges(int[] nums) {
+    List<String> list = new ArrayList<>();
+    int idx = 0;
+    int n = nums.length;
+    while (idx < n) {
+      int start = nums[idx];
+      int prev = start;
+      idx++;
+      while (idx < n && nums[idx] - prev == 1) {
+        prev = nums[idx];
+        idx++;
+      }
+      list.add(start == prev ? String.valueOf(start) : String.valueOf(start + "->" + prev));
     }
+    return list;
+  }
 }

From da4655d88b71f71dac12c5b6261d830852a0b6ea Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 24 Dec 2019 08:25:10 +0530
Subject: [PATCH 0071/2175] Refactored 3 solutions

---
 Easy/Search Insert Position.java              |  38 +++---
 ...d Search Word - Data structure design.java | 112 ++++++++----------
 Medium/Plus One Linked List.java              |  58 +++------
 3 files changed, 83 insertions(+), 125 deletions(-)

diff --git a/Easy/Search Insert Position.java b/Easy/Search Insert Position.java
index f36a96c8..b6187b17 100644
--- a/Easy/Search Insert Position.java	
+++ b/Easy/Search Insert Position.java	
@@ -1,25 +1,19 @@
 class Solution {
-    public int searchInsert(int[] nums, int target) {
-        return binarySearch(nums, target);
-    }
-    
-    private int binarySearch(int[] nums, int target) {
-        int left = 0;
-        int right = nums.length - 1;
-        
-        while (left <= right) {
-            int mid = (left + right) / 2;
-            if (nums[mid] == target) {
-                return mid;
-            }
-            else if (nums[mid] > target) {
-                right = mid - 1;
-            }
-            else {
-                left = mid + 1;
-            }
-        }
-        
-        return left;
+  public int searchInsert(int[] nums, int target) {
+    int low = 0;
+    int high = nums.length - 1;
+    while (low <= high) {
+      int mid = (low + high) / 2;
+      if (nums[mid] == target) {
+        return mid;
+      }
+      else if (nums[mid] > target) {
+        high = mid - 1;
+      }
+      else {
+        low = mid + 1;
+      }
     }
+    return low;
+  }
 }
diff --git a/Medium/Add and Search Word - Data structure design.java b/Medium/Add and Search Word - Data structure design.java
index de90b231..2d73cc43 100644
--- a/Medium/Add and Search Word - Data structure design.java	
+++ b/Medium/Add and Search Word - Data structure design.java	
@@ -1,73 +1,63 @@
 class WordDictionary {
 
-    /** Initialize your data structure here. */
-    TrieNode root;
-    public WordDictionary() {
-        root = new TrieNode();
-    }
-    
-    /** Adds a word into the data structure. */
-    public void addWord(String word) {
-        addToTrie(word);
+  /** Initialize your data structure here. */
+  Node root;
+  public WordDictionary() {
+    root = new Node('-');
+  }
+
+  /** Adds a word into the data structure. */
+  public void addWord(String word) {
+    Node curr = root;
+    for (char c : word.toCharArray()) {
+      if (curr.children[c - 'a'] == null) {
+        curr.children[c - 'a'] = new Node(c);
+      }
+      curr = curr.children[c - 'a'];
     }
-    
-    private void addToTrie(String word) {
-        TrieNode curr = root;
-        for (int i = 0; i < word.length(); i++) {
-            char c = word.charAt(i);
-            if (curr.children[c - 'a'] == null) {
-                curr.children[c - 'a'] = new TrieNode();
-            }
-            
-            curr = curr.children[c - 'a'];
-            
-            if (i == word.length() - 1) {
-                curr.isWord = true;
-            }
-        }
+    curr.isWord = true;
+  }
+
+  /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
+  public boolean search(String word) {
+    Node curr = root;
+    return searchHelper(curr, word, 0);
+  }
+  
+  private boolean searchHelper(Node curr, String word, int idx) {
+    if (idx == word.length()) {
+      return curr.isWord;
     }
-    
-    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
-    public boolean search(String word) {
-        TrieNode curr = root;
-        boolean[] ans = {false};
-        helper(word, 0, curr, ans);
-        return ans[0];
+    char c = word.charAt(idx);
+    if (c != '.') {
+      if (curr.children[c - 'a'] == null) {
+        return false;
+      }
+      return searchHelper(curr.children[c - 'a'], word, idx + 1);
     }
-    
-    private void helper(String word, int idx, TrieNode curr, boolean[] ans) {
-        if (curr == null) {
-            return;
-        }
-        
-        if (idx == word.length()) {
-            if (curr.isWord) {
-                ans[0] = true;
-            }
-            return;
-        }
-        
-        if (word.charAt(idx) != '.') {
-            helper(word, idx + 1, curr.children[word.charAt(idx) - 'a'], ans);
-        }
-        else {
-            for (int i = 0; i < 26; i++) {
-                if (curr.children[i] != null) {
-                    helper(word, idx + 1, curr.children[i], ans);
-                }
-            }
+    else {
+      boolean flag = false;
+      for (Node child : curr.children) {
+        if (child != null) {
+          flag = flag | searchHelper(child, word, idx + 1);
         }
+      }
+      return flag;
     }
+  }
 }
 
-class TrieNode {
-    TrieNode[] children;
-    boolean isWord;
-        
-    public TrieNode() {
-        children = new TrieNode[26];
-        isWord = false;
-    }
+
+class Node {
+  char c;
+  Node[] children;
+  boolean isWord;
+  
+  public Node(char c) {
+    this.c = c;
+    children = new Node[26];
+    isWord = false;
+  }
 }
 
 /**
diff --git a/Medium/Plus One Linked List.java b/Medium/Plus One Linked List.java
index 2af7c374..79a5a666 100644
--- a/Medium/Plus One Linked List.java	
+++ b/Medium/Plus One Linked List.java	
@@ -7,48 +7,22 @@
  * }
  */
 class Solution {
-    public ListNode plusOne(ListNode head) {
-        ListNode rev = reverse(head);
-        ListNode prev = null;
-        int carry = 1;
-        ListNode curr = rev;
-        while (curr != null) {
-            int temp = curr.val + carry;
-            if (temp > 9) {
-                carry = 1;
-                temp = temp - 10;
-            }
-            else {
-                carry = 0;
-            }
-            
-            prev = curr;
-            
-            curr.val = temp;
-            curr = curr.next;
-        }
-        
-        if (carry != 0) {
-            prev.next = new ListNode(carry);
-        }
-        
-        ListNode ans = reverse(rev);
-        
-        return ans;
+  public ListNode plusOne(ListNode head) {
+    ListNode dummy = new ListNode(0);
+    dummy.next = head;
+    ListNode notNine = dummy;
+    while (head != null) {
+      if (head.val != 9) {
+        notNine = head;
+      }
+      head = head.next;
     }
-    
-    private ListNode reverse(ListNode node) {
-        ListNode curr = node;
-        ListNode prev = null;
-        ListNode next = null;
-        
-        while (curr != null) {
-            next = curr.next;
-            curr.next = prev;
-            prev = curr;
-            curr = next;
-        }
-        
-        return prev;
+    notNine.val++;
+    notNine = notNine.next;
+    while (notNine != null) {
+      notNine.val = 0;
+      notNine = notNine.next;
     }
+    return dummy.val != 0 ? dummy : dummy.next;
+  } 
 }

From 337907b70a1742a7d93f93a843490c7dbe522ff5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 25 Dec 2019 08:39:06 +0530
Subject: [PATCH 0072/2175] Modified 4 solutions

---
 Easy/Remove Duplicates From Sorted Lists.java |  29 ++---
 ...Remove Duplicates from Sorted List II.java |  46 ++++----
 Medium/Set Matrix Zeroes.java                 | 111 ++++++++----------
 Medium/Unique Paths.java                      |  35 +++---
 4 files changed, 105 insertions(+), 116 deletions(-)

diff --git a/Easy/Remove Duplicates From Sorted Lists.java b/Easy/Remove Duplicates From Sorted Lists.java
index 8fb4fc2a..53626725 100644
--- a/Easy/Remove Duplicates From Sorted Lists.java	
+++ b/Easy/Remove Duplicates From Sorted Lists.java	
@@ -7,23 +7,16 @@
  * }
  */
 class Solution {
-    public ListNode deleteDuplicates(ListNode head) {
-        if (head == null) return head;
-        ListNode copyHead = head;
-        while (head.next != null) {
-            if (head.val == head.next.val) {
-                if(head.next.next == null) {
-                    head.next = null;
-                    break;
-                }
-                else {
-                    head.next = head.next.next;
-                }
-            }
-            else {
-                head = head.next;
-            }
-        }
-        return copyHead;
+  public ListNode deleteDuplicates(ListNode head) {
+    ListNode curr = head;
+    while (curr != null) {
+      if (curr.next != null && curr.val == curr.next.val) {
+        curr.next = curr.next.next;
+      }
+      else {
+        curr = curr.next;
+      }
     }
+    return head;
+  }
 }
diff --git a/Medium/Remove Duplicates from Sorted List II.java b/Medium/Remove Duplicates from Sorted List II.java
index 007ecd17..77c6672f 100644
--- a/Medium/Remove Duplicates from Sorted List II.java	
+++ b/Medium/Remove Duplicates from Sorted List II.java	
@@ -7,26 +7,30 @@
  * }
  */
 class Solution {
-    public ListNode deleteDuplicates(ListNode head) {
-        if(head==null) return null;
-        
-        ListNode FakeHead=new ListNode(0);
-        FakeHead.next=head;
-        ListNode pre=FakeHead;
-        ListNode cur=head;
-        
-        while(cur!=null){
-            while(cur.next!=null&&cur.val==cur.next.val){
-                cur=cur.next;
-            }
-            if(pre.next==cur){
-                pre=pre.next;
-            }
-            else{
-                pre.next=cur.next;
-            }
-            cur=cur.next;
-        }
-        return FakeHead.next;
+  public ListNode deleteDuplicates(ListNode head) {
+    ListNode dummy = new ListNode(0);
+    dummy.next = head;
+    ListNode prev = dummy;
+    ListNode curr = head;
+    while (curr != null) {
+      int val = curr.val;
+      int count = 0;
+      ListNode temp = curr;
+      // Track the number of occurrences of value of current node
+      while (temp != null && temp.val == val) {
+        temp = temp.next;
+        count++;
+      }
+      // Update prev.next to the temp which can be a null or node with different value
+      if (count > 1) {
+        prev.next = temp;
+        curr = temp;
+      }
+      else {
+        prev = curr;
+        curr = curr.next;
+      }
     }
+    return dummy.next;
+  }
 }
diff --git a/Medium/Set Matrix Zeroes.java b/Medium/Set Matrix Zeroes.java
index 6c043646..5aad58c2 100644
--- a/Medium/Set Matrix Zeroes.java	
+++ b/Medium/Set Matrix Zeroes.java	
@@ -1,64 +1,57 @@
 class Solution {
-    public void setZeroes(int[][] arr) {
-        if (arr.length == 0 || arr[0].length == 0) {
-            return;
-        }
-
-
-        int numOfRows = arr.length;
-        int numOfCols = arr[0].length;
-        boolean firstRowZero = false;
-        boolean firstColZero = false;
-
-        for (int i = 0; i < numOfCols; i++) {
-            if (arr[0][i] == 0) {
-                firstRowZero = true;
-                break;
-            }
-        }
-
-        for (int i = 0; i < numOfRows; i++) {
-            if (arr[i][0] == 0) {
-                firstColZero = true;
-                break;
-            }
-        }
-
-        for (int i = 1; i < numOfRows; i++) {
-            for (int j = 0; j < numOfCols; j++) {
-                if (arr[i][j] == 0) {
-                    arr[0][j] = 0;
-                    arr[i][0] = 0;
-                }
-            }
-        }
-
-        for (int i = 1; i < numOfRows; i++) {
-            if (arr[i][0] == 0) {
-                for (int j = 1; j < numOfCols; j++) {
-                    arr[i][j] = 0;
-                }
-            }
-        }
-
-        for (int i = 0; i < numOfCols; i++) {
-            if (arr[0][i] == 0) {
-                for (int j = 1; j < numOfRows; j++) {
-                    arr[j][i] = 0;
-                }
-            }
-        }
-
-        if (firstRowZero) {
-            for (int i = 0; i < numOfCols; i++) {
-                arr[0][i] = 0;
-            }
+  public void setZeroes(int[][] matrix) {
+    boolean firstRowZero = false;
+    boolean firstColZero = false;
+    int numRows = matrix.length;
+    int numCols = matrix[0].length;
+    // Mark if first column needs to be set zero
+    for (int i = 0; i < numRows; i++) {
+      if (matrix[i][0] == 0) {
+        firstColZero = true;
+      }
+    }
+    // Mark if first row needs to be set zero
+    for (int i = 0; i < numCols; i++) {
+      if (matrix[0][i] == 0) {
+        firstRowZero = true;
+      }
+    }
+    // If a value in matrix is zero set the value at first row and column to be zero
+    for (int i = 1; i < numRows; i++) {
+      for (int j = 1; j < numCols; j++) {
+        if (matrix[i][j] == 0) {
+          matrix[0][j] = 0;
+          matrix[i][0] = 0;
+        }
+      }
+    }
+    // Update the complete column to be zero if first item of row is zero
+    for (int i = 1; i < numRows; i++) {
+      if (matrix[i][0] == 0) {
+        for (int j = 1; j < numCols; j++) {
+          matrix[i][j] = 0;
         }
-
-        if (firstColZero) {
-            for (int i = 0; i < numOfRows; i++) {
-                arr[i][0] = 0;
-            }
+      }
+    }
+    // Update the complete row to be zero if first item of column is zero
+    for (int i = 1; i < numCols; i++) {
+      if (matrix[0][i] == 0) {
+        for (int j = 1; j < numRows; j++) {
+          matrix[j][i] = 0;
         }
+      } 
+    }
+    // Set the first row to zero if flag is set
+    if (firstRowZero) {
+      for (int i = 0; i < numCols; i++) {
+        matrix[0][i] = 0;
+      }
+    }
+    // Set the first column to zero if flag is set
+    if (firstColZero) {
+      for (int i = 0; i < numRows; i++) {
+        matrix[i][0] = 0;
+      }
     }
+  }
 }
diff --git a/Medium/Unique Paths.java b/Medium/Unique Paths.java
index 9a80ee80..5bea1273 100644
--- a/Medium/Unique Paths.java	
+++ b/Medium/Unique Paths.java	
@@ -1,22 +1,21 @@
 class Solution {
-
-    public int uniquePaths(int m, int n) {
-        int[][] arr = new int[m][n];
-        return getCount(arr, m, n);        
+  Integer[][] dp;
+  public int uniquePaths(int m, int n) {
+    dp = new Integer[m][n];
+    return dfs(m, n, 0, 0);
+  }
+  
+  private int dfs(int m, int n, int x, int y) {
+    if (x >= m || y >= n) {
+      return 0;
     }
-    
-    private int getCount(int[][] arr, int m, int n) {
-        for (int i=0; i<arr.length; i++) {
-            for (int j=0; j<arr[0].length; j++) {
-                if (i == 0 || j ==0) {
-                    arr[i][j] = 1;
-                }
-                else {
-                    arr[i][j] = arr[i-1][j] + arr[i][j-1];
-                }
-            }
-        }
-        
-        return arr[m-1][n-1];
+    if (dp[x][y] != null) {
+      return dp[x][y];
     }
+    if (x == m - 1 && y == n - 1) {
+      return 1;
+    }
+    dp[x][y] = dfs(m, n, x + 1, y) + dfs(m, n, x, y + 1);
+    return dp[x][y];
+  }
 }

From 5b428bd89a017524eb28aaef15b5b4884d35606a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 26 Dec 2019 06:45:47 +0530
Subject: [PATCH 0073/2175] Added one solution & refactored one solution

---
 Easy/Binary Search.java                       | 38 +++++++++----------
 ...d Smallest Letter Greater Than Target.java | 24 ++++++++++++
 2 files changed, 42 insertions(+), 20 deletions(-)
 create mode 100644 Easy/Find Smallest Letter Greater Than Target.java

diff --git a/Easy/Binary Search.java b/Easy/Binary Search.java
index baaf9570..32630594 100644
--- a/Easy/Binary Search.java	
+++ b/Easy/Binary Search.java	
@@ -1,23 +1,21 @@
 class Solution {
-    public int search(int[] nums, int target) {
-        return searchImpl(nums, target, 0, nums.length-1);
-    }
-    
-    public int searchImpl(int[] nums, int target, int start, int end) {
-        if (start > end) {
-            return -1;
-        }
-        
-        int mid = (start + end)/2;
-        
-        if (nums[mid] == target) {
-            return mid;
-        }
-        else if (nums[mid] > target) {
-            return searchImpl(nums, target, start, mid-1);
-        }
-        else {
-            return searchImpl(nums, target, mid+1, end);
-        }
+  public int search(int[] nums, int target) {
+    return binarySearchImpl(nums, 0, nums.length - 1, target);
+  }
+  
+  private int binarySearchImpl(int[] nums, int start, int end, int target) {
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (nums[mid] == target) {
+        return mid;
+      }
+      else if (nums[mid] > target) {
+        end = mid - 1;
+      }
+      else {
+        start = mid + 1;
+      }
     }
+    return -1;
+  }
 }
diff --git a/Easy/Find Smallest Letter Greater Than Target.java b/Easy/Find Smallest Letter Greater Than Target.java
new file mode 100644
index 00000000..161760cb
--- /dev/null
+++ b/Easy/Find Smallest Letter Greater Than Target.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public char nextGreatestLetter(char[] letters, char target) {
+    int start = 0;
+    int end = letters.length - 1;
+    // ASCII char greater than 'z'
+    char smallestChar = '{';
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (letters[mid] - target > 0) {
+        if (smallestChar - letters[mid] > 0) {
+          smallestChar = letters[mid];
+        }
+        end = mid - 1;
+      }
+      else if (letters[mid] - target == 0) {
+        start = mid + 1;
+      }
+      else {
+        start = mid + 1;
+      }
+    }
+    return smallestChar == '{' ? letters[0] : smallestChar;
+  }
+}

From ceb10b8c9c8aa5233035921d494ce1de469ba5e4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 27 Dec 2019 15:55:09 +0530
Subject: [PATCH 0074/2175] Refactored Flatten 2D Vector.java

---
 Medium/Flatten 2D Vector.java | 63 +++++++++++++++--------------------
 1 file changed, 26 insertions(+), 37 deletions(-)

diff --git a/Medium/Flatten 2D Vector.java b/Medium/Flatten 2D Vector.java
index d3d815bb..c9c0ce8c 100644
--- a/Medium/Flatten 2D Vector.java	
+++ b/Medium/Flatten 2D Vector.java	
@@ -1,44 +1,33 @@
-class Vector2D implements Iterator<Integer> {
+class Vector2D {
+  int vectorIdx;
+  int currIdx;
+  int[][] v;
+  public Vector2D(int[][] v) {
+    vectorIdx = 0;
+    currIdx = 0;
+    this.v = v;
+  }
 
-    Iterator<List<Integer>> listIterator;
-    Iterator<Integer> iterator;
-    boolean flag;
+  public int next() {
+    hasNext();
+    return v[vectorIdx][currIdx++];
+  }
 
-    public Vector2D(List<List<Integer>> vec2d) {
-        listIterator = vec2d.iterator();
-        check();
-    }
-
-    private void check() {
-        while (listIterator.hasNext()) {
-            List<Integer> list = listIterator.next();
-            if (list.size() > 0) {
-                iterator = list.iterator();
-                break;
-            }
-        }
-
-        flag = iterator != null;
-    }
-
-    @Override
-    public Integer next() {
-        int num = iterator.next();
-        if (!iterator.hasNext()) {
-            iterator = null;
-            check();
-        }
-
-        return num;
-    }
-
-    @Override
-    public boolean hasNext() {
-        return flag;
+  public boolean hasNext() {
+    while (vectorIdx < v.length) {
+      if (currIdx < v[vectorIdx].length) {
+        return true;
+      }
+      vectorIdx++;
+      currIdx = 0;
     }
+    return false;
+  }
 }
+
 /**
  * Your Vector2D object will be instantiated and called as such:
- * Vector2D i = new Vector2D(vec2d);
- * while (i.hasNext()) v[f()] = i.next();
+ * Vector2D obj = new Vector2D(v);
+ * int param_1 = obj.next();
+ * boolean param_2 = obj.hasNext();
  */

From 7e5921db17d7930f98be631694285495edf2fcb9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 29 Dec 2019 11:51:22 -0800
Subject: [PATCH 0075/2175] Added 2 solutions

---
 ...Find N Unique Integers Sum up to Zero.java | 20 +++++++
 ...l Elements in Two Binary Search Trees.java | 55 +++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 Easy/Find N Unique Integers Sum up to Zero.java
 create mode 100644 Medium/All Elements in Two Binary Search Trees.java

diff --git a/Easy/Find N Unique Integers Sum up to Zero.java b/Easy/Find N Unique Integers Sum up to Zero.java
new file mode 100644
index 00000000..3eb3d777
--- /dev/null
+++ b/Easy/Find N Unique Integers Sum up to Zero.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int[] sumZero(int n) {
+    int[] arr = new int[n];
+    int idx = 0;
+    int num = n / 2;
+    while (idx < n / 2) {
+      arr[idx++] = num * -1;
+      num--;
+    }
+    if (n % 2 != 0) {
+      arr[idx++] = 0;
+    }
+    num = n / 2;
+    while (idx < n) {
+      arr[idx++] = num;
+      num--;
+    }
+    return arr;
+  }
+}
diff --git a/Medium/All Elements in Two Binary Search Trees.java b/Medium/All Elements in Two Binary Search Trees.java
new file mode 100644
index 00000000..4c535e00
--- /dev/null
+++ b/Medium/All Elements in Two Binary Search Trees.java	
@@ -0,0 +1,55 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  List<Integer> ans;
+  public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
+    ans = new ArrayList<>();
+    helper(root1, root2);
+    return ans;
+  }
+  
+  private void helper(TreeNode r1, TreeNode r2) {
+    Stack<TreeNode> stack1 = new Stack<>();
+    Stack<TreeNode> stack2 = new Stack<>();
+    addToStack(stack1, r1);
+    addToStack(stack2, r2);
+    while (!stack1.isEmpty() || !stack2.isEmpty()) {
+      TreeNode popped1 = stack1.isEmpty() ? null : stack1.pop();
+      TreeNode popped2 = stack2.isEmpty() ? null : stack2.pop();
+      if (popped1 != null && popped2 != null) {
+        if (popped1.val > popped2.val) {
+          ans.add(popped2.val);
+          addToStack(stack2, popped2.right);
+          stack1.push(popped1);
+        }
+        else {
+          ans.add(popped1.val);
+          addToStack(stack1, popped1.right);
+          stack2.push(popped2);
+        }
+      }
+      else if (popped2 == null) {
+        ans.add(popped1.val);
+        addToStack(stack1, popped1.right);
+      }
+      else {
+        ans.add(popped2.val);
+        addToStack(stack2, popped2.right);
+      }
+    }
+  }
+  
+  private void addToStack(Stack<TreeNode> stack, TreeNode node) {
+    while (node != null) {
+      stack.push(node);
+      node = node.left;
+    }
+  }
+}

From 9ac0bd99557de389841aac1af2c50e612326ef24 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 30 Dec 2019 06:14:58 -0800
Subject: [PATCH 0076/2175] Added 3 solutions & modified 1 solution

---
 ...s with Greatest Element on Right Side.java | 11 ++++
 Hard/Number of Paths with Max Score.java      | 42 +++++++++++++++
 Medium/Deepest Leaves Sum.java                | 32 ++++++++++++
 Medium/Find and Replace Pattern.java          | 52 ++++++++-----------
 4 files changed, 107 insertions(+), 30 deletions(-)
 create mode 100644 Easy/Replace Elements with Greatest Element on Right Side.java
 create mode 100644 Hard/Number of Paths with Max Score.java
 create mode 100644 Medium/Deepest Leaves Sum.java

diff --git a/Easy/Replace Elements with Greatest Element on Right Side.java b/Easy/Replace Elements with Greatest Element on Right Side.java
new file mode 100644
index 00000000..12e4405a
--- /dev/null
+++ b/Easy/Replace Elements with Greatest Element on Right Side.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int[] replaceElements(int[] arr) {
+    int maxVal = -1;
+    for (int i = arr.length - 1; i >= 0; i--) {
+      int temp = arr[i];
+      arr[i] = maxVal;
+      maxVal = Math.max(maxVal, temp);
+    }
+    return arr;
+  }
+}
diff --git a/Hard/Number of Paths with Max Score.java b/Hard/Number of Paths with Max Score.java
new file mode 100644
index 00000000..576a6942
--- /dev/null
+++ b/Hard/Number of Paths with Max Score.java	
@@ -0,0 +1,42 @@
+class Solution {
+  int[][] dirs = {{-1, 0}, {0, -1}, {-1, -1}};
+  final int MOD = 1000000007;
+  int[][] dpSum;
+  int[][] dpCount;
+  public int[] pathsWithMaxScore(List<String> board) {
+    int numRows = board.size();
+    int numCols = board.get(0).length();
+    dpSum = new int[numRows][numCols];
+    dpCount = new int[numRows][numCols];
+    dpCount[numRows - 1][numCols - 1] = 1;
+    helper(board, numRows, numCols);
+    return new int[]{dpSum[0][0], dpCount[0][0]};
+  }
+  
+  private void helper(List<String> board, int numRows, int numCols) {
+    for (int x = numRows - 1; x >= 0; x--) {
+      for (int y = numCols - 1; y >= 0; y--) {
+        if (dpCount[x][y] == 0) {
+          continue;
+        }
+        for (int[] dir : dirs) {
+          int newX = x + dir[0];
+          int newY = y + dir[1];
+          if (newX >= 0 && newY >= 0 && board.get(newX).charAt(newY) != 'X') {
+            int tempSum = dpSum[x][y];
+            if (board.get(newX).charAt(newY) != 'E') {
+              tempSum += Character.getNumericValue(board.get(newX).charAt(newY));
+            }
+            if (tempSum > dpSum[newX][newY]) {
+              dpCount[newX][newY] = dpCount[x][y];
+              dpSum[newX][newY] = tempSum;
+            }
+            else if (tempSum == dpSum[newX][newY]) {
+              dpCount[newX][newY] = (dpCount[newX][newY] + dpCount[x][y]) % MOD;
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/Medium/Deepest Leaves Sum.java b/Medium/Deepest Leaves Sum.java
new file mode 100644
index 00000000..82138314
--- /dev/null
+++ b/Medium/Deepest Leaves Sum.java	
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  Map<Integer, Integer> map;
+  int deepestLevel;
+  public int deepestLeavesSum(TreeNode root) {
+    map = new HashMap<>();
+    deepestLevel = 0;
+    helper(root, 0);
+    return map.get(deepestLevel);
+  }
+  
+  private void helper(TreeNode root, int level) {
+    if (root == null) {
+      return;
+    }
+    if (root.left == null && root.right == null) {
+      map.put(level, map.getOrDefault(level, 0) + root.val);
+      deepestLevel = Math.max(deepestLevel, level);
+      return;
+    }
+    helper(root.left, level + 1);
+    helper(root.right, level + 1);
+  }
+}
diff --git a/Medium/Find and Replace Pattern.java b/Medium/Find and Replace Pattern.java
index 839486ba..8a54adbe 100644
--- a/Medium/Find and Replace Pattern.java	
+++ b/Medium/Find and Replace Pattern.java	
@@ -1,34 +1,26 @@
 class Solution {
-    public static List<String> findAndReplacePattern(String[] words, String pattern) {
-        String givenPattern = getStringPattern(pattern);
-        List<String> ans = new ArrayList<>();
-
-        for (String word : words) {
-            if (getStringPattern(word).equals(givenPattern)) {
-                ans.add(word);
-            }
-        }
-
-        return ans;
+  public List<String> findAndReplacePattern(String[] words, String pattern) {
+    String patternCode = getCode(pattern);
+    List<String> list = new ArrayList<>();
+    for (String word : words) {
+      String wordCode = getCode(word);
+      if (wordCode.equals(patternCode)) {
+        list.add(word);
+      }
     }
-
-    private static String getStringPattern(String pattern) {
-        StringBuilder sb = new StringBuilder();
-        char[] chars = pattern.toCharArray();
-        int val = 0;
-        Map<Character, Integer> map = new HashMap<>();
-
-        for (char c : chars) {
-            if (!map.containsKey(c)) {
-                map.put(c, val);
-                val++;
-            }
-        }
-
-        for (int i=0; i<chars.length; i++) {
-            sb.append(map.get(chars[i]));
-        }
-
-        return sb.toString();
+    return list;
+  }
+  
+  private String getCode(String word) {
+    Map<Character, Integer> map = new HashMap<>();
+    StringBuilder sb = new StringBuilder();
+    int count = 0;
+    for (char c : word.toCharArray()) {
+      if (!map.containsKey(c)) {
+        map.put(c, count++);
+      }
+      sb.append(map.get(c));
     }
+    return sb.toString();
+  }
 }

From ece674fa90fc55fe36a3082faf1ec5e08acb7f63 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 31 Dec 2019 06:18:57 -0800
Subject: [PATCH 0077/2175] Refactored 4 solutions

---
 Easy/Closest Binary Search Tree Value.java | 41 ++++++++--------
 Easy/Goat Latin.java                       | 37 +++++++--------
 Easy/Monotonic Array.java                  | 35 +++++++++-----
 Easy/Verifying an Alien Dictionary.java    | 55 ++++++++++------------
 4 files changed, 83 insertions(+), 85 deletions(-)

diff --git a/Easy/Closest Binary Search Tree Value.java b/Easy/Closest Binary Search Tree Value.java
index f4277609..0f1ad50c 100644
--- a/Easy/Closest Binary Search Tree Value.java	
+++ b/Easy/Closest Binary Search Tree Value.java	
@@ -8,29 +8,26 @@
  * }
  */
 class Solution {
-    int ans = 0;
+  public int closestValue(TreeNode root, double target) {
+    int[] ans = {0};
     double minDiff = Double.MAX_VALUE;
-    
-    public int closestValue(TreeNode root, double target) {
-        updateVal(root, target);    
-        return ans;
+    helper(root, target, ans, minDiff);
+    return ans[0];
+  }
+  
+  private void helper(TreeNode root, double target, int[] ans, double minDiff) {
+    if (root == null) {
+      return;
     }
-    
-    private void updateVal(TreeNode root, double target) {
-        if (root == null) {
-            return;
-        }
-        
-        if (Math.abs(root.val - target) < minDiff) {
-            minDiff = Math.abs(root.val - target);
-            ans = root.val;
-        }
-        
-        if (root.val < target) {
-            updateVal(root.right, target);
-        }
-        else {
-            updateVal(root.left, target);
-        }
+    if (Math.abs(root.val - target) < minDiff) {
+      minDiff = Math.abs(root.val - target);
+      ans[0] = root.val;
     }
+    if (root.val < target) {
+      helper(root.right, target, ans, minDiff);
+    }
+    else {
+      helper(root.left, target, ans, minDiff);
+    }
+  }
 }
diff --git a/Easy/Goat Latin.java b/Easy/Goat Latin.java
index 59e3e20e..c62aec2c 100644
--- a/Easy/Goat Latin.java	
+++ b/Easy/Goat Latin.java	
@@ -1,24 +1,19 @@
 class Solution {
-    public static String toGoatLatin(String S) {
-    	
-    	StringBuilder sb = new StringBuilder("");
-    	String[] strs = S.split("\\s+");
-    	
-    	String vowels = "aeiou";
-    	StringBuilder suffix = new StringBuilder("a");
-    	
-    	for (String s : strs) {
-    		if (vowels.indexOf(s.toLowerCase().charAt(0)) != -1) {
-    			sb.append(s).append("ma").append(suffix).append(" ");
-    		}
-    		else {
-    			sb.append(s.substring(1, s.length())).append(s.charAt(0)).append("ma").append(suffix).append(" ");
-    		}
-    		
-    		suffix.append("a");
-    	}
-        
-        return sb.toString().trim();
+  public String toGoatLatin(String S) {
+    StringBuilder addAString = new StringBuilder("a");
+    StringBuilder sb = new StringBuilder();
+    Set<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u'));
+    String[] strs = S.split("\\s+");
+    for (int i = 0; i < strs.length; i++) {
+      if (vowels.contains(Character.toLowerCase(strs[i].charAt(0)))) {
+        sb.append(strs[i]);
+      }
+      else {
+        sb.append(strs[i].substring(1)).append(strs[i].charAt(0));
+      }
+      sb.append("ma").append(addAString.toString()).append(" ");
+      addAString.append("a");
     }
+    return sb.toString().trim();
+  }
 }
-
diff --git a/Easy/Monotonic Array.java b/Easy/Monotonic Array.java
index e05fe225..b9a44bcb 100644
--- a/Easy/Monotonic Array.java	
+++ b/Easy/Monotonic Array.java	
@@ -1,16 +1,25 @@
 class Solution {
-    public boolean isMonotonic(int[] A) {
-        if (A.length <= 2) return true;
-        boolean pattern = A[A.length-1] > A[0] ? true : false;
-        
-        for (int i=1; i<A.length; i++) {
-            if (A[i] < A[i-1] && pattern == true) {
-                return false;
-            }
-            if (A[i] > A[i-1] && pattern == false) {
-                return false;
-            }
-        }
-        return true;
+  public boolean isMonotonic(int[] A) {
+    if (A.length <= 1) {
+      return true;
     }
+    int dir = 0;
+    int idx = 0;
+    while (idx < A.length - 1 && dir == 0) {
+      dir = getDir(A, idx);
+      idx++;
+    }
+    while (idx < A.length - 1) {
+      int tempDir = getDir(A, idx);
+      if (tempDir != 0 && tempDir != dir) {
+        return false;
+      }
+      idx++;
+    }
+    return true;
+  }
+  
+  private int getDir(int[] A, int idx) {
+    return A[idx] < A[idx + 1] ? -1 : (A[idx] > A[idx + 1] ? 1 : 0);
+  }
 }
diff --git a/Easy/Verifying an Alien Dictionary.java b/Easy/Verifying an Alien Dictionary.java
index d9445ba0..ceccf55b 100644
--- a/Easy/Verifying an Alien Dictionary.java	
+++ b/Easy/Verifying an Alien Dictionary.java	
@@ -1,33 +1,30 @@
 class Solution {
-    public boolean isAlienSorted(String[] words, String order) {
-        Map<Character, Integer> orderMap = new HashMap<>();
-        for (int i=0; i<order.length(); i++) {
-            orderMap.put(order.charAt(i), i);
-        }
-        
-        String prev = null;
-        
-        for (String word : words) {
-            if (prev == null) {
-                prev = word;
-                continue;
-            }
-            
-            for (int i=0; i<Math.min(prev.length(), word.length()); i++) {
-                if (orderMap.get(word.charAt(i)) > orderMap.get(prev.charAt(i))) {
-                    break;
-                }
-                else if (orderMap.get(word.charAt(i)) < orderMap.get(prev.charAt(i))) {
-                    return false;
-                } 
-                else if (word.length() != prev.length() && i == word.length() - 1) {
-                    return false;
-                }
-            }
-            
-            prev = word;
-        }
-        
+  public boolean isAlienSorted(String[] words, String order) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (int i = 0; i < order.length(); i++) {
+      map.put(order.charAt(i), i);
+    }
+    for (int i = 0; i < words.length - 1; i++) {
+      if (!verifyHelper(words[i], words[i + 1], map)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  private boolean verifyHelper(String s1, String s2, Map<Character, Integer> map) {
+    int idx1 = 0;
+    int idx2 = 0;
+    while (idx1 < s1.length() && idx2 < s2.length()) {
+      if (map.get(s1.charAt(idx1)) < map.get(s2.charAt(idx2))) {
         return true;
+      }
+      if (map.get(s1.charAt(idx1)) > map.get(s2.charAt(idx2))) {
+        return false;
+      }
+      idx1++;
+      idx2++;
     }
+    return s1.length() <= s2.length();
+  }
 }

From e529f20d3ef0111bc1353de62c1dbdc6e90a57c0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 1 Jan 2020 14:07:35 -0800
Subject: [PATCH 0078/2175] Added 1 solution & modified 2 solutions

---
 Medium/Interval List Intersections.java       |  55 +++-----
 ...imum Remove to Make Valid Parentheses.java |  29 ++++
 ...rtical Order Traversal Of Binary Tree.java | 133 +++++++-----------
 3 files changed, 95 insertions(+), 122 deletions(-)
 create mode 100644 Medium/Minimum Remove to Make Valid Parentheses.java

diff --git a/Medium/Interval List Intersections.java b/Medium/Interval List Intersections.java
index b65b26e8..0b7c1033 100644
--- a/Medium/Interval List Intersections.java	
+++ b/Medium/Interval List Intersections.java	
@@ -1,39 +1,22 @@
 class Solution {
-    public int[][] intervalIntersection(int[][] A, int[][] B) {
-        List<int[]> intersections = new ArrayList<>();
-        int idx1 = 0;
-        int idx2 = 0;
-    
-        while (idx1 < A.length && idx2 < B.length) {
-            if (A[idx1][0] > B[idx2][1]) {
-                idx2++;
-                continue;
-            }
-            
-            if (A[idx1][1] < B[idx2][0]) {
-                idx1++;
-                continue;
-            }
-            
-            int maxStart = Math.max(A[idx1][0], B[idx2][0]);
-            int minEnd = Math.min(A[idx1][1], B[idx2][1]);
-            
-            int[] interval = {maxStart, minEnd};
-            intersections.add(interval);
-            
-            if (A[idx1][1] > B[idx2][1]) {
-                idx2++;
-            }
-            else {
-                idx1++;
-            }
-        }
-        
-        int[][] ans = new int[intersections.size()][2];
-        for (int i = 0; i < intersections.size(); i++) {
-            ans[i] = intersections.get(i);
-        }
-        
-        return ans;
+  public int[][] intervalIntersection(int[][] A, int[][] B) {
+    List<int[]> list = new ArrayList<>();
+    int startA = 0;
+    int startB = 0;
+    while (startA < A.length && startB < B.length) {
+      int intervalStart = Math.max(A[startA][0], B[startB][0]);
+      int intervalEnd = Math.min(A[startA][1], B[startB][1]);
+      if (intervalStart <= intervalEnd) {
+        list.add(new int[]{intervalStart, intervalEnd});
+      }
+      if (A[startA][1] < B[startB][1]) {
+        startA++;
+      }
+      else {
+        startB++;
+      }
     }
+    int[][] ans = new int[list.size()][2];
+    return list.toArray(ans);
+  }
 }
diff --git a/Medium/Minimum Remove to Make Valid Parentheses.java b/Medium/Minimum Remove to Make Valid Parentheses.java
new file mode 100644
index 00000000..bc1739e4
--- /dev/null
+++ b/Medium/Minimum Remove to Make Valid Parentheses.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public String minRemoveToMakeValid(String s) {
+    Stack<Integer> stack = new Stack<>();
+    char[] chars = s.toCharArray();
+    for (int i = 0; i < chars.length; i++) {
+      if (chars[i] == '(') {
+        stack.push(i);
+      }
+      else if (chars[i] == ')') {
+        if (stack.isEmpty()) {
+          chars[i] = '-';
+        }
+        else {
+          stack.pop();
+        }
+      }
+    }
+    while (!stack.isEmpty()) {
+      chars[stack.pop()] = '-';
+    }
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < chars.length; i++) {
+      if (chars[i] != '-') {
+        sb.append(chars[i]);
+      }
+    }
+    return sb.toString();
+  }
+}
diff --git a/Medium/Vertical Order Traversal Of Binary Tree.java b/Medium/Vertical Order Traversal Of Binary Tree.java
index a4bb8784..0459a5f6 100644
--- a/Medium/Vertical Order Traversal Of Binary Tree.java	
+++ b/Medium/Vertical Order Traversal Of Binary Tree.java	
@@ -8,95 +8,56 @@
  * }
  */
 class Solution {
-    class NewNode {
-        TreeNode t;
-        int x;
-        int y;
-        int level;
-        
-        NewNode(TreeNode t, int x, int y, int level) {
-            this.t = t;
-            this.x = x;
-            this.y = y;
-            this.level = level;
-        }
+  public List<List<Integer>> verticalTraversal(TreeNode root) {
+    if (root == null) {
+      return new ArrayList<>();
     }
-    
-    int maxLeft;
-    int maxRight;
-    Map<Integer, List<NewNode>> map;
-    
-    public List<List<Integer>> verticalTraversal(TreeNode root) {
-        maxLeft = 0;    
-        maxRight = 0;
-        map = new HashMap<>();
-        
-        helper(root, 0);
-        
-        List<List<Integer>> list = new ArrayList<>();
-        
-        while (maxLeft <= maxRight) {
-            if (map.containsKey(maxLeft)) {
-                List<NewNode> temp = map.get(maxLeft);
-                
-                Collections.sort(temp, new Comparator<NewNode>() {
-                    @Override
-                    public int compare(NewNode o1, NewNode o2) {
-                        int c = Integer.valueOf(o1.x).compareTo(Integer.valueOf(o2.x));
-                        if (c == 0) {
-                            c = Integer.valueOf(o2.y).compareTo(Integer.valueOf(o1.y));
-                        }
-                        
-                        if (c == 0) {
-                            c = Integer.valueOf(o1.t.val).compareTo(Integer.valueOf(o2.t.val));
-                        }
-                        
-                        return c;
-                    }
-                });
-                
-                List<Integer> valList = new ArrayList<>();
-                for (NewNode node : temp) {
-                    valList.add(node.t.val);
-                }
-                
-                list.add(valList);
-            }
-            
-            maxLeft++;
+    Map<Integer, List<TreeLevel>> map = new TreeMap<>();
+    Queue<TreeLevel> queue = new LinkedList<>();
+    queue.add(new TreeLevel(root, 0, 0));
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeLevel removed = queue.remove();
+        map.computeIfAbsent(removed.xLevel, k -> new ArrayList<>()).add(removed);
+        if (removed.node.left != null) {
+          queue.add(new TreeLevel(removed.node.left, removed.xLevel - 1, removed.yLevel - 1));
         }
-        
-        return list;
-    }
-    
-    private void helper(TreeNode root, int level) {
-        if (root == null) {
-            return;
+        if (removed.node.right != null) {
+          queue.add(new TreeLevel(removed.node.right, removed.xLevel + 1, removed.yLevel - 1));
         }
-        
-        NewNode node = new NewNode(root, 0, 0, level);
-        Queue<NewNode> queue = new LinkedList<>();
-        
-        queue.add(node);
-        
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            
-            while (size-- > 0) {
-                NewNode temp = queue.remove();
-                map.computeIfAbsent(temp.level, k -> new ArrayList<>()).add(temp);
-                
-                maxLeft = Math.min(maxLeft, temp.level - 1);
-                maxRight = Math.max(maxRight, temp.level + 1);
-                
-                if (temp.t.left != null) {
-                    queue.add(new NewNode(temp.t.left, temp.x - 1, temp.y - 1, temp.level - 1));
-                }
-                
-                if (temp.t.right != null) {
-                    queue.add(new NewNode(temp.t.right, temp.x + 1, temp.y - 1, temp.level + 1));
-                }
-            }
+      }
+    }
+    List<List<Integer>> list = new ArrayList<>();
+    for (Integer key : map.keySet()) {
+      List<TreeLevel> temp = map.get(key);
+      Collections.sort(temp, new Comparator<TreeLevel>(){
+        public int compare(TreeLevel t1, TreeLevel t2) {
+          int c = t2.yLevel - t1.yLevel;
+          if (c == 0) {
+            c = t1.node.val - t2.node.val;
+          }
+          return c;
         }
+      });
+      List<Integer> valTemp = new ArrayList<>();
+      for (TreeLevel t : temp) {
+        valTemp.add(t.node.val);
+      }
+      list.add(valTemp);
     }
+    return list;
+  }
+}
+
+class TreeLevel {
+  TreeNode node;
+  int xLevel;
+  int yLevel;
+  
+  public TreeLevel(TreeNode node, int xLevel, int yLevel) {
+    this.node = node;
+    this.xLevel = xLevel;
+    this.yLevel = yLevel;
+  }
 }

From 30597d5a0e5191faa78eae52d394e51ed6dd0487 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 2 Jan 2020 06:25:13 -0800
Subject: [PATCH 0079/2175] Added 1 solution & refactored 3 solutions

---
 Easy/Two Sum Less Than K.java                 |  29 +++--
 .../Analyze User Website Visit Pattern.java   | 106 +++++++++---------
 Medium/Letter Tiles Possibilities.java        |  42 ++++---
 Medium/Minimum Cost to Connect Sticks.java    |  17 +++
 4 files changed, 101 insertions(+), 93 deletions(-)
 create mode 100644 Medium/Minimum Cost to Connect Sticks.java

diff --git a/Easy/Two Sum Less Than K.java b/Easy/Two Sum Less Than K.java
index c8376739..7a74f60d 100644
--- a/Easy/Two Sum Less Than K.java	
+++ b/Easy/Two Sum Less Than K.java	
@@ -1,20 +1,17 @@
 class Solution {
-    public int twoSumLessThanK(int[] A, int K) {
-        TreeSet<Integer> set = new TreeSet<>();
-        int maxSum = -1;
-        
-        for (int i = 0; i < A.length; i++) {
-            int diff = K - A[i];
-            if (diff > 0) {
-                Integer second = set.lower(diff);
-                if (second != null) {
-                    maxSum = Math.max(maxSum, A[i] + second);
-                }
-            }
-            
-            set.add(A[i]);
+  public int twoSumLessThanK(int[] A, int K) {
+    int maxSum = -1;
+    TreeSet<Integer> set = new TreeSet<>();
+    for (int i = 0; i < A.length; i++) {
+      int diff = K - A[i];
+      if (diff > 0) {
+        Integer half = set.lower(diff);
+        if (half != null) {
+          maxSum = Math.max(maxSum, A[i] + half);
         }
-
-        return maxSum;
+      }
+      set.add(A[i]);
     }
+    return maxSum;
+  }
 }
diff --git a/Medium/Analyze User Website Visit Pattern.java b/Medium/Analyze User Website Visit Pattern.java
index 400c473e..a15fbec5 100644
--- a/Medium/Analyze User Website Visit Pattern.java	
+++ b/Medium/Analyze User Website Visit Pattern.java	
@@ -1,60 +1,58 @@
 class Solution {
-    public List<String> mostVisitedPattern(String[] username, int[] timestamp, String[] website) {
-        Map<String, List<Visit>> visitMap = new HashMap<>();
-        int n = username.length;
-        for (int i = 0; i < n; i++) {
-            visitMap.computeIfAbsent(username[i], k -> new ArrayList<>()).add(new Visit(timestamp[i], website[i]));
-        }
-        
-        Map<String, Integer> tripletMap = new HashMap<>();
-        for (String user : visitMap.keySet()) {
-            List<Visit> visits = visitMap.get(user);
-            Collections.sort(visits);
-            Set<String> visited = new HashSet<>();
-            for (int i = 0; i < visits.size(); i++) {
-                for (int j = i + 1; j < visits.size(); j++) {
-                    for (int k = j + 1; k < visits.size(); k++) {
-                        String tempTriplet = visits.get(i).website + "," +  visits.get(j).website + "," + visits.get(k).website;
-                        if (visited.add(tempTriplet)) {
-                            tripletMap.put(tempTriplet, tripletMap.getOrDefault(tempTriplet, 0) + 1);
-                        }
-                    }
-                }
-            }
-        }
-        
-        int maxValue = 0;
-        String res = "";
-        for (String triplet : tripletMap.keySet()) {
-            if (tripletMap.get(triplet) > maxValue) {
-                maxValue = tripletMap.get(triplet);
-                res = triplet;
-            }
-            else if (tripletMap.get(triplet) == maxValue) {
-                if (triplet.compareTo(res) < 0) {
-                    res = triplet;
-                }
-            }
-        }
-        
-        return Arrays.asList(res.split(","));
+  public List<String> mostVisitedPattern(String[] username, int[] timestamp, String[] website) {
+    List<List<String>> sessions = new ArrayList<>();
+    int n = timestamp.length;
+    // Form a session list -> user[i] at timestamp[i] visited website[i]
+    for (int i = 0; i < n; i++) {
+      sessions.add(new ArrayList<>());
+      sessions.get(i).add(username[i]);
+      sessions.get(i).add(String.valueOf(timestamp[i]));
+      sessions.get(i).add(website[i]);
     }
-}
-
-class Visit implements Comparable<Visit> {
-    int timestamp;
-    String website;
-    
-    public Visit(int timestamp, String website) {
-        this.timestamp = timestamp;
-        this.website = website;
+    // Sort by timestamp
+    sessions.sort((a, b) -> Integer.parseInt(a.get(1)) - Integer.parseInt(b.get(1)));
+    Map<String, List<String>> visited = new HashMap<>();
+    // Create a hashmap user -> list of websites visited
+    for (int i = 0; i < n; i++) {
+      visited.computeIfAbsent(sessions.get(i).get(0), k -> new ArrayList<>()).add(sessions.get(i).get(2));
     }
-    
-    public String toString() {
-        return timestamp + "->" + website;
+    Map<String, Integer> sequence = new HashMap<>();
+    int maxCount = 0;
+    String maxSeq = "";
+    for (String name : visited.keySet()) {
+      if (visited.get(name).size() >= 3) {
+        // Form all possible combination of websites visited of size 3
+        Set<String> subseqences = subseqence(visited.get(name));
+        for (String seq : subseqences){
+          sequence.put(seq, sequence.getOrDefault(seq, 0) + 1);
+          if(sequence.get(seq) > maxCount){
+            maxCount = sequence.get(seq);
+            maxSeq = seq;
+          }
+          else if (sequence.get(seq) == maxCount && seq.compareTo(maxSeq) < 0) {
+            maxSeq = seq;
+          }
+        }
+      }
+    }
+    String[] strs = maxSeq.split(",");
+    List<String> res = new ArrayList<>();
+    for (String s : strs) {
+      res.add(s);
     }
-    
-    public int compareTo(Visit visit) {
-        return this.timestamp - visit.timestamp;
+    return res;
+  }
+  
+  private Set<String> subseqence(List<String> list) {
+    Set<String> set = new HashSet<>();
+    int n = list.size();
+    for (int i = 0; i < n - 2; i++) {
+      for (int j = i + 1; j < n - 1; j++) {
+        for (int k = j + 1; k < n; k++) {
+          set.add(list.get(i) + "," + list.get(j) + "," + list.get(k));
+        }
+      }
     }
+    return set;
+  }
 }
diff --git a/Medium/Letter Tiles Possibilities.java b/Medium/Letter Tiles Possibilities.java
index 298b0215..92c37fcf 100644
--- a/Medium/Letter Tiles Possibilities.java	
+++ b/Medium/Letter Tiles Possibilities.java	
@@ -1,27 +1,23 @@
 class Solution {
-    public int numTilePossibilities(String tiles) {
-        int[] occCount = new int[26];
-        for (char c : tiles.toCharArray()) {
-            occCount[c - 'A']++;
-        }
-        
-        return dfsHelper(occCount);
+  public int numTilePossibilities(String tiles) {
+    int[] count = new int[26];
+    for (char c : tiles.toCharArray()) {
+      count[c - 'A']++;
     }
-    
-    private int dfsHelper(int[] occCount) {
-        int sum = 0;
-        
-        for (int i = 0; i < 26; i++) {
-            if (occCount[i] == 0) {
-                continue;
-            }
-            
-            sum++;
-            occCount[i]--;
-            sum += dfsHelper(occCount);
-            occCount[i]++;
-        }
-        
-        return sum;
+    return dfs(count);
+  }
+  
+  private int dfs(int[] count) {
+    int sum = 0;
+    for (int i = 0; i < 26; i++) {
+      if (count[i] == 0) {
+        continue;
+      }
+      sum++;
+      count[i]--;
+      sum += dfs(count);
+      count[i]++;
     }
+    return sum;
+  }
 }
diff --git a/Medium/Minimum Cost to Connect Sticks.java b/Medium/Minimum Cost to Connect Sticks.java
new file mode 100644
index 00000000..0bd1c1bf
--- /dev/null
+++ b/Medium/Minimum Cost to Connect Sticks.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int connectSticks(int[] sticks) {
+    int cost = 0;
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    for (int stick : sticks) {
+      pq.add(stick);
+    }
+    while (pq.size() > 1) {
+      int first = pq.poll();
+      int second = pq.poll();
+      int joinSum = first + second;
+      cost += joinSum;
+      pq.add(joinSum);
+    }
+    return cost;
+  }
+}

From 087ddb0c5ec3a7afdebae947d51e4598c95ba3a5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 3 Jan 2020 05:51:13 -0800
Subject: [PATCH 0080/2175] Added 2 solutions & refactored 2 solutions

---
 ...ny Apples Can You Put into the Basket.java | 21 ++---
 Easy/Sort Array By Parity.java                | 20 ++++
 Medium/Boundary of Binary Tree.java           | 92 +++++++++----------
 Medium/Search Suggestions System.java         | 36 ++++++++
 4 files changed, 107 insertions(+), 62 deletions(-)
 create mode 100644 Easy/Sort Array By Parity.java
 create mode 100644 Medium/Search Suggestions System.java

diff --git a/Easy/How Many Apples Can You Put into the Basket.java b/Easy/How Many Apples Can You Put into the Basket.java
index 99345d35..4626ce53 100644
--- a/Easy/How Many Apples Can You Put into the Basket.java	
+++ b/Easy/How Many Apples Can You Put into the Basket.java	
@@ -1,15 +1,12 @@
 class Solution {
-    public int maxNumberOfApples(int[] arr) {
-        Arrays.sort(arr);
-        int total = 0;
-        int count = 0;
-        for (int i = 0; i < arr.length; i++) {
-            total += arr[i];
-            if (total > 5000) {
-                break;
-            }
-            count++;
-        }
-        return count;
+  public int maxNumberOfApples(int[] arr) {
+    int weight = 0;
+    int currCount = 0;
+    Arrays.sort(arr);
+    for (int i = 0; i < arr.length && weight + arr[i] <= 5000; i++) {
+      weight += arr[i];
+      currCount++;
     }
+    return currCount;
+  }
 }
diff --git a/Easy/Sort Array By Parity.java b/Easy/Sort Array By Parity.java
new file mode 100644
index 00000000..9e86cbd8
--- /dev/null
+++ b/Easy/Sort Array By Parity.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int[] sortArrayByParity(int[] A) {
+    int start = 0;
+    int end = A.length - 1;
+    while (start < end) {
+      if (A[start] % 2 > A[end] % 2) {
+        int temp = A[start];
+        A[start] = A[end];
+        A[end] = temp;
+      }
+      if (A[start] % 2 == 0) {
+        start++;
+      }
+      if (A[end] % 2 != 0) {
+        end--;
+      }
+    }
+    return A;
+  }
+}
diff --git a/Medium/Boundary of Binary Tree.java b/Medium/Boundary of Binary Tree.java
index 140f5c25..41aa86ea 100644
--- a/Medium/Boundary of Binary Tree.java	
+++ b/Medium/Boundary of Binary Tree.java	
@@ -8,58 +8,50 @@
  * }
  */
 class Solution {
-    List<Integer> list;
-    int backIdx;
-    public List<Integer> boundaryOfBinaryTree(TreeNode root) {
-        list = new ArrayList<>();
-        backIdx = 0;
-        
-        if (root == null) {
-            return list;
-        }
-        
-        list.add(root.val);
-        
-        addLeft(root.left);
-        addLeaves(root.left);
-        addLeaves(root.right);
-        addRight(root.right);
-        
-        return list;
+  public List<Integer> boundaryOfBinaryTree(TreeNode root) {
+    List<Integer> list = new ArrayList<>();
+    List<Integer> right = new ArrayList<>();
+    if (root == null) {
+      return list;
     }
-    
-    private void addLeft(TreeNode node) {
-        if (node == null || (node.left == null && node.right == null)) {
-            return;
-        }
-        
-        list.add(node.val);
-        
-        addLeft(node.left == null ? node.right : node.left);
+    list.add(root.val);
+    addLeft(root.left, list);
+    addLeaves(root.left, list);
+    addLeaves(root.right, list);
+    addRight(root.right, right);
+    for (int i = right.size() - 1; i >= 0; i--) {
+      list.add(right.get(i));
     }
-    
-    private void addRight(TreeNode node) {
-        if (node == null || (node.right == null && node.left == null)) {
-            return;
-        }
-        
-        list.add(list.size() - backIdx, node.val);
-        backIdx++;
-        
-        addRight(node.right == null ? node.left : node.right);
+    return list;
+  }
+  
+  private void addLeft(TreeNode root, List<Integer> list) {
+    if (root == null || (root.left == null && root.right == null)) {
+      return;
     }
-    
-    private void addLeaves(TreeNode node) {
-        if (node == null) {
-            return;
-        }
-        
-        if (node.left == null && node.right == null) {
-            list.add(node.val);    
-            return;
-        } 
-        
-        addLeaves(node.left);
-        addLeaves(node.right);
+    list.add(root.val);
+    addLeft(root.left == null ? root.right : root.left, list);
+  }
+  
+  private void addRight(TreeNode root, List<Integer> list) {
+    if (root == null || (root.left == null && root.right == null)) {
+      return;
     }
+    list.add(root.val);
+    TreeNode next = root.right == null ? root.left : root.right;
+    addRight(root.right == null ? root.left : root.right, list);
+  }
+  
+  private void addLeaves(TreeNode root, List<Integer> list) {
+    if (root == null) {
+      return;
+    }
+    if (root.left == null && root.right == null) {
+      list.add(root.val);
+    }
+    else {
+      addLeaves(root.left, list);
+      addLeaves(root.right, list);
+    }
+  }
 }
diff --git a/Medium/Search Suggestions System.java b/Medium/Search Suggestions System.java
new file mode 100644
index 00000000..618e4fe5
--- /dev/null
+++ b/Medium/Search Suggestions System.java	
@@ -0,0 +1,36 @@
+class Solution {
+  public List<List<String>> suggestedProducts(String[] products, String searchWord) {
+    List<List<String>> ans = new ArrayList<>();
+    List<String> prev = new ArrayList<>();
+    for (int i = 0; i < searchWord.length(); i++) {
+      List<String> curr = new ArrayList<>();
+      List<String> temp = new ArrayList<>();
+      PriorityQueue<String> pq = new PriorityQueue<>(Comparator.reverseOrder());
+      if (i == 0) {
+        helper(Arrays.asList(products), searchWord, i, curr, pq);
+      }
+      else {
+        helper(prev, searchWord, i, curr, pq);
+      }
+      while (!pq.isEmpty()) {
+        temp.add(pq.poll());
+      }
+      Collections.sort(temp);
+      ans.add(temp);
+      prev = curr;
+    }
+    return ans;
+  }
+
+  private void helper(List<String> products, String searchWord, int i, List<String> curr, PriorityQueue<String> pq) {
+    for (String word : products) {
+      if (i < word.length() && word.charAt(i) == searchWord.charAt(i)) {
+        curr.add(word);
+        pq.add(word);
+        if (pq.size() > 3) {
+          pq.poll();
+        }
+      }
+    }
+  }
+}

From b3bc4434bb0910277e7d4e96a7119fbc5dfa977d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 4 Jan 2020 13:41:07 -0800
Subject: [PATCH 0081/2175] Added 1 solution

---
 Medium/Koko Eating Bananas.java | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 Medium/Koko Eating Bananas.java

diff --git a/Medium/Koko Eating Bananas.java b/Medium/Koko Eating Bananas.java
new file mode 100644
index 00000000..f0a7f6cb
--- /dev/null
+++ b/Medium/Koko Eating Bananas.java	
@@ -0,0 +1,33 @@
+class Solution {
+  public int minEatingSpeed(int[] piles, int H) {
+    int maxSize = piles[0];
+    for (int pile : piles) {
+      maxSize = Math.max(pile, maxSize);
+    }
+    return helper(piles, H, 1, maxSize);
+  }
+  
+  private int helper(int[] piles, int H, int start, int end) {
+    while (start < end) {
+      int mid = (start + end) / 2;
+      if (isPossible(piles, H, mid)) {
+        end = mid; 
+      }
+      else {
+        start = mid + 1;
+      }
+    }
+    return start;
+  }
+  
+  private boolean isPossible(int[] piles, int H, int check) {
+    int numOfHours = 0;
+    for (int pile : piles) {
+      int quot = pile / check; 
+      numOfHours += quot == 0 ? 1 : quot;
+      numOfHours += quot > 0 && pile % check != 0 ? 1 : 0;
+    }
+    return numOfHours <= H;
+  }
+}
+

From 1965aab4425739bbabe3fcce7e9effa210f9bcb2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 7 Jan 2020 06:29:06 -0800
Subject: [PATCH 0082/2175] Added 1 solution & refactored 2 solutions

---
 ...ring from Alphabet to Integer Mapping.java | 21 +++++++
 Easy/Repeated Substring Pattern.java          | 21 +++++--
 Medium/Find Peak Element.java                 | 58 +++++++------------
 3 files changed, 59 insertions(+), 41 deletions(-)
 create mode 100644 Easy/Decrypt String from Alphabet to Integer Mapping.java

diff --git a/Easy/Decrypt String from Alphabet to Integer Mapping.java b/Easy/Decrypt String from Alphabet to Integer Mapping.java
new file mode 100644
index 00000000..08b2561c
--- /dev/null
+++ b/Easy/Decrypt String from Alphabet to Integer Mapping.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public String freqAlphabets(String s) {
+    StringBuilder sb = new StringBuilder();
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      char c = s.charAt(idx);
+      int asciiAdd = -1;
+      if (idx + 2 < n && s.charAt(idx + 2) == '#') {
+        asciiAdd = Integer.parseInt(s.substring(idx, idx + 2));
+        idx += 3;
+      }
+      else {
+        asciiAdd = Integer.parseInt(s.substring(idx, idx + 1));
+        idx++;
+      }
+      sb.append((char) (96 + asciiAdd));
+    }
+    return sb.toString();
+  }
+}
diff --git a/Easy/Repeated Substring Pattern.java b/Easy/Repeated Substring Pattern.java
index b47d5001..e766601b 100644
--- a/Easy/Repeated Substring Pattern.java	
+++ b/Easy/Repeated Substring Pattern.java	
@@ -1,8 +1,19 @@
 class Solution {
-    public boolean repeatedSubstringPattern(String s) {
-        String s1 = s + s;
-        String s2 = s1.substring(1,s1.length()-1);
-        
-        return s2.contains(s);
+  public boolean repeatedSubstringPattern(String s) {
+    int n = s.length();
+    for (int i = n / 2; i >= 0; i--) {
+      if (i != 0 && n % i == 0) {
+        int count = n / i;
+        StringBuilder sb = new StringBuilder();
+        String sub = s.substring(0, i);
+        while (count-- > 0) {
+          sb.append(sub);
+        }
+        if (sb.toString().equals(s)) {
+          return true;
+        }
+      }
     }
+    return false;
+  }
 }
diff --git a/Medium/Find Peak Element.java b/Medium/Find Peak Element.java
index 103b184e..b90994cc 100644
--- a/Medium/Find Peak Element.java	
+++ b/Medium/Find Peak Element.java	
@@ -1,39 +1,25 @@
 class Solution {
-    public static int findPeakElement(int[] nums) {
-        if (nums.length == 1) {
-            return 0;
-        }
-        
-        return findPeakElementImpl(nums, 0, nums.length-1);
-    }
-
-    private static int findPeakElementImpl(int[] nums, int start, int end) {
-        if (start > end) {
-            return -1;
-        }
-
-        int mid = (start + end)/2;
-
-        if (mid == 0 && nums.length > 1) {
-            if (nums[mid] > nums[mid+1]) {
-                return mid;
-            }
-        }
-        else if (mid == nums.length-1 && nums.length > 1) {
-            if (nums[mid] > nums[mid-1]) {
-                return mid;
-            }
-        }
-        else {
-            if (nums.length > 1) {
-                if (nums[mid] > nums[mid-1] && nums[mid] > nums[mid+1]) {
-                    return mid;
-                }
-            }
-        }
-
-        int left = findPeakElementImpl(nums, start, mid-1);
-
-        return left == -1 ? findPeakElementImpl(nums, mid+1, end) : left;
+  public int findPeakElement(int[] nums) {
+    int[] index = {-1};
+    helper(nums, 0, nums.length - 1, index);
+    return index[0];
+  }
+  
+  private void helper(int[] nums, int start, int end, int[] index) {
+    if (start <= end && index[0] == -1) {
+      int mid = (start + end) / 2;
+      boolean found = (
+          (mid + 1 < nums.length ? nums[mid] > nums[mid + 1] : true) &&
+          (mid - 1 >= 0 ? nums[mid] > nums[mid - 1] : true)
+        );
+      if (found) {
+        index[0] = mid;
+        return;
+      }
+      else {
+        helper(nums, start, mid - 1, index);
+        helper(nums, mid + 1, end, index);
+      }
     }
+  }
 }

From 8d50ada4e9f8c7a157896a8ebf39f32a2b2b4257 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 8 Jan 2020 06:25:55 -0800
Subject: [PATCH 0083/2175] Added 1 solution

---
 Easy/Flower Planting With No Adjacent.java | 25 ++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Flower Planting With No Adjacent.java

diff --git a/Easy/Flower Planting With No Adjacent.java b/Easy/Flower Planting With No Adjacent.java
new file mode 100644
index 00000000..70ea74de
--- /dev/null
+++ b/Easy/Flower Planting With No Adjacent.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int[] gardenNoAdj(int N, int[][] paths) {
+    Map<Integer, List<Integer>> map = new HashMap<>();
+    for (int[] path : paths) {
+      map.computeIfAbsent(path[0], k -> new ArrayList<>()).add(path[1]);
+      map.computeIfAbsent(path[1], k -> new ArrayList<>()).add(path[0]);
+    }
+    int[] ans = new int[N];
+    for (int i = 0; i < N; i++) {
+      Set<Integer> neighbourPlant = new HashSet<>();
+      for (Integer neighbour : map.getOrDefault(i + 1, new ArrayList<>())) {
+        if (ans[neighbour - 1] != 0) {
+          neighbourPlant.add(ans[neighbour - 1]);
+        }
+      }
+      for (int j = 1; j <= 4; j++) {
+        if (!neighbourPlant.contains(j)) {
+          ans[i] = j;
+          break;
+        }
+      }
+    }
+    return ans;
+  }
+}

From 6bdf4510ebb90deed0c3216d2e4cb96b0d3fe5eb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 9 Jan 2020 06:54:22 -0800
Subject: [PATCH 0084/2175] Added 1 solution

---
 Medium/Flip Equivalent Binary Trees.java | 31 ++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Flip Equivalent Binary Trees.java

diff --git a/Medium/Flip Equivalent Binary Trees.java b/Medium/Flip Equivalent Binary Trees.java
new file mode 100644
index 00000000..7829ff4d
--- /dev/null
+++ b/Medium/Flip Equivalent Binary Trees.java	
@@ -0,0 +1,31 @@
+i/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  public boolean flipEquiv(TreeNode root1, TreeNode root2) {
+    if (root1 == null && root2 == null) {
+      return true;
+    }
+    if (root1 == null || root2 == null) {
+      return false;
+    }
+    if (root1.val != root2.val) {
+      return false;
+    }
+    return (
+        (
+          flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right)
+        ) || 
+        (
+          flipEquiv(root1.left, root2.right) && 
+          flipEquiv(root1.right, root2.left)
+        )
+      );
+  }
+}

From 1b66fce154e876f8f17d26bcfe0ff95a909e48bc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 11 Jan 2020 19:17:17 -0800
Subject: [PATCH 0085/2175] Added 2 solutions

---
 Easy/Decompress Run-Length Encoded List.java  | 18 ++++++++++++
 ...of Nodes with Even-Valued Grandparent.java | 29 +++++++++++++++++++
 2 files changed, 47 insertions(+)
 create mode 100644 Easy/Decompress Run-Length Encoded List.java
 create mode 100644 Medium/Sum of Nodes with Even-Valued Grandparent.java

diff --git a/Easy/Decompress Run-Length Encoded List.java b/Easy/Decompress Run-Length Encoded List.java
new file mode 100644
index 00000000..caf7b35a
--- /dev/null
+++ b/Easy/Decompress Run-Length Encoded List.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int[] decompressRLElist(int[] nums) {
+    int count = 0;
+    for (int i = 0; i < nums.length; i += 2) {
+      count += nums[i];
+    }
+    int idx = 0;
+    int[] ans = new int[count];
+    for (int i = 1; i < nums.length; i+= 2) {
+      int freq = nums[i - 1];
+      int val = nums[i];
+      while (freq-- > 0) {
+        ans[idx++] = val;
+      }
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Sum of Nodes with Even-Valued Grandparent.java b/Medium/Sum of Nodes with Even-Valued Grandparent.java
new file mode 100644
index 00000000..e872e123
--- /dev/null
+++ b/Medium/Sum of Nodes with Even-Valued Grandparent.java	
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  public int sumEvenGrandparent(TreeNode root) {
+    int[] ans = {0};
+    helper(root, -1, -1, ans);
+    return ans[0];
+  }
+  
+  private void helper(TreeNode root, int parent, int grandparent, int[] ans) {
+    if (root == null) {
+      return;
+    }
+    if (grandparent > 0 && grandparent % 2 == 0) {
+      ans[0] += root.val;
+    }
+    grandparent = parent;
+    parent = root.val;
+    helper(root.left, parent, grandparent, ans);
+    helper(root.right, parent, grandparent, ans);
+  }
+}

From 399b9c962ebf4fc694143c021c5e55ed658da019 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 14 Jan 2020 06:33:48 -0800
Subject: [PATCH 0086/2175] Refactored one solution

---
 Medium/Custom Sort String.java | 47 +++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/Medium/Custom Sort String.java b/Medium/Custom Sort String.java
index 15bd4cbd..1fe011ce 100644
--- a/Medium/Custom Sort String.java	
+++ b/Medium/Custom Sort String.java	
@@ -1,27 +1,26 @@
 class Solution {
-    public String customSortString(String S, String T) {
-        int[] counter = new int[26];
-        for (char c : T.toCharArray()) {
-            counter[c - 'a']++;
-        }
-        
-        StringBuilder sb = new StringBuilder();
-        for (char c : S.toCharArray()) {
-            int count = counter[c - 'a'];
-            for (int i = 0; i < count; i++) {
-                sb.append(c);
-            }
-            
-            counter[c - 'a'] = 0;
-        }
-        
-        for (char c ='a'; c <= 'z'; c++) {
-            int count = counter[c - 'a'];
-            for (int i = 0; i < count; i++) {
-                sb.append(c);
-            }
-        }
-        
-        return sb.toString();
+  public String customSortString(String S, String T) {
+    Set<Character> set = new HashSet<>();
+    for (int i = 0; i < S.length(); i++) {
+      set.add(S.charAt(i));
     }
+    Map<Character, Integer> map = new HashMap<>();
+    StringBuilder sb = new StringBuilder();
+    for (char c : T.toCharArray()) {
+      if (set.contains(c)) {
+        map.put(c, map.getOrDefault(c, 0) + 1);
+      }
+      else {
+        sb.append(c);
+      }
+    }
+    for (int i = 0; i < S.length(); i++) {
+      char c = S.charAt(i);
+      int count = map.getOrDefault(c, 0);
+      while (count-- > 0) {
+        sb.append(c);
+      }
+    }
+    return sb.toString();
+  }
 }

From aab42e8f45e37cc880ec6a141facb51ae12e6590 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 16 Jan 2020 07:33:41 -0800
Subject: [PATCH 0087/2175] Refactored 3 solutions

---
 Easy/Height Checker.java                      | 22 +++++-----
 Easy/Number of 1 bits.java                    | 23 +++++-----
 .../Number of Dice Rolls With Target Sum.java | 42 ++++++++++---------
 3 files changed, 44 insertions(+), 43 deletions(-)

diff --git a/Easy/Height Checker.java b/Easy/Height Checker.java
index 09efad95..56949329 100644
--- a/Easy/Height Checker.java	
+++ b/Easy/Height Checker.java	
@@ -1,15 +1,13 @@
 class Solution {
-    public int heightChecker(int[] heights) {
-        int[] copy = Arrays.copyOf(heights, heights.length);
-        Arrays.sort(copy);
-
-        int count = 0;
-        for (int i = 0; i < heights.length; i++) {
-            if (copy[i] != heights[i]) {
-                count++;
-            }
-        }
-
-        return count;
+  public int heightChecker(int[] heights) {
+    int[] copy = Arrays.copyOf(heights, heights.length);
+    Arrays.sort(copy);
+    int count = 0;
+    for (int i = 0; i < heights.length; i++) {
+      if (heights[i] != copy[i]) {
+        count++;
+      }
     }
+    return count;
+  }
 }
diff --git a/Easy/Number of 1 bits.java b/Easy/Number of 1 bits.java
index d8ac73f6..698d620b 100644
--- a/Easy/Number of 1 bits.java	
+++ b/Easy/Number of 1 bits.java	
@@ -1,15 +1,14 @@
 public class Solution {
-    // you need to treat n as an unsigned value
-    public int hammingWeight(int n) {
-        int count = 0;
-        for (int i=0; i<32; i++) {
-            if ((n & 1) == 1) {
-                count++;
-            }
-            
-            n = n >> 1;
-        }
-        
-        return count;
+  // you need to treat n as an unsigned value
+  public int hammingWeight(int n) {
+    int bits = 0;
+    int mask = 1;
+    for (int i = 0; i < 32; i++) {
+      if ((n & mask) != 0) {
+        bits++;
+      }
+      mask <<= 1;
     }
+    return bits;
+  }
 }
diff --git a/Medium/Number of Dice Rolls With Target Sum.java b/Medium/Number of Dice Rolls With Target Sum.java
index eb157eb6..6e600168 100644
--- a/Medium/Number of Dice Rolls With Target Sum.java	
+++ b/Medium/Number of Dice Rolls With Target Sum.java	
@@ -1,23 +1,27 @@
 class Solution {
-    int MOD = 1000000007;
-    public int numRollsToTarget(int d, int f, int target) {
-        Integer[][] dp = new Integer[d + 1][target + 1];
-        return helper(d, f, target, dp);
+  Map<String, Integer> map = new HashMap<>();
+  final int MODULO = 1000000007;
+  public int numRollsToTarget(int d, int f, int target) {
+    if (d == 0 && target == 0) {
+      return 1;
     }
-    
-    private int helper(int d, int f, int target, Integer[][] dp) {
-        if (d == 0 || target <= 0) {
-            return d == target ? 1 : 0;
-        }
-        if (dp[d][target] != null) {
-            return dp[d][target];
-        }
-        
-        dp[d][target] = 0;
-        for (int i = 1; i <= f; i++) {
-            dp[d][target] = (dp[d][target] + helper(d - 1, f, target - i, dp)) % MOD; 
-        }
-        
-        return dp[d][target];
+    if (d == 0 || target == 0) {
+      return 0;
     }
+    String key = d + "|" + target;
+    if (map.containsKey(key)) {
+      return map.get(key);
+    }
+    int res = 0;
+    for (int i = 1; i <= f; i++) {
+      if (target >= i) {
+        res = (res + numRollsToTarget(d - 1, f, target - i)) % MODULO;
+      }
+      else {
+        break;
+      }
+    }
+    map.put(key, res);
+    return map.get(key);
+  }
 }

From f600d3d215f683c45839ff04f28080978afb21bc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 25 Jan 2020 14:52:47 -0800
Subject: [PATCH 0088/2175] Added 3 solutions

---
 Easy/Maximum 69 Number.java          | 12 ++++++++++++
 Easy/Rank Transform of an Array.java | 22 ++++++++++++++++++++++
 Medium/Break a Palindrome.java       | 24 ++++++++++++++++++++++++
 3 files changed, 58 insertions(+)
 create mode 100644 Easy/Maximum 69 Number.java
 create mode 100644 Easy/Rank Transform of an Array.java
 create mode 100644 Medium/Break a Palindrome.java

diff --git a/Easy/Maximum 69 Number.java b/Easy/Maximum 69 Number.java
new file mode 100644
index 00000000..ae9e7383
--- /dev/null
+++ b/Easy/Maximum 69 Number.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int maximum69Number (int num) {
+    char[] chars = String.valueOf(num).toCharArray();
+    for (int i = 0; i < chars.length; i++) {
+      if (chars[i] == '6') {
+        chars[i] = '9';
+        break;
+      }
+    }
+    return Integer.parseInt(String.valueOf(chars));
+  }
+}
diff --git a/Easy/Rank Transform of an Array.java b/Easy/Rank Transform of an Array.java
new file mode 100644
index 00000000..9d6c0629
--- /dev/null
+++ b/Easy/Rank Transform of an Array.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int[] arrayRankTransform(int[] arr) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    Map<Integer, Integer> map = new HashMap<>();
+    int rank = 1;
+    for (int num : arr) {
+      pq.add(num);
+    }
+    while (!pq.isEmpty()) {
+      int num = pq.poll();
+      if (!map.containsKey(num)) {
+        map.put(num, rank);
+        rank++;
+      }
+    }
+    int[] rankArr = new int[arr.length];
+    for (int i = 0; i < arr.length; i++) {
+      rankArr[i] = map.get(arr[i]);
+    }
+    return rankArr;
+  }
+}
diff --git a/Medium/Break a Palindrome.java b/Medium/Break a Palindrome.java
new file mode 100644
index 00000000..eca6bb8b
--- /dev/null
+++ b/Medium/Break a Palindrome.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public String breakPalindrome(String palindrome) {
+    // If empty or of length 1 => return empty
+    if (palindrome.length() <= 1) {
+      return "";
+    }
+    char[] chars = palindrome.toCharArray();
+    for (int i = 0; i < chars.length; i++) {
+      if (chars[i] != 'a') {
+        // Skip if the string is of odd length and it is the middle index
+        if (palindrome.length() % 2 != 0 && i == palindrome.length() / 2) {
+          continue;
+        }
+        chars[i] = 'a';
+        break;
+      }
+      // If all chars all 'a' update last char to 'b'
+      if (i == chars.length - 1) {
+        chars[i] = 'b';
+      }
+    }
+    return String.valueOf(chars);
+  }
+}

From 42a6d39bc19bc528b02bd935ac911ee7e58d869e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Jan 2020 17:32:05 -0800
Subject: [PATCH 0089/2175] Added 2 solutions

---
 Easy/Nim Game.java                            |  5 ++++
 ...by Vegan-Friendly, Price and Distance.java | 25 +++++++++++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 Easy/Nim Game.java
 create mode 100644 Medium/Filter Restaurants by Vegan-Friendly, Price and Distance.java

diff --git a/Easy/Nim Game.java b/Easy/Nim Game.java
new file mode 100644
index 00000000..26f74660
--- /dev/null
+++ b/Easy/Nim Game.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public boolean canWinNim(int n) {
+    return n % 4 != 0;
+  }
+}
diff --git a/Medium/Filter Restaurants by Vegan-Friendly, Price and Distance.java b/Medium/Filter Restaurants by Vegan-Friendly, Price and Distance.java
new file mode 100644
index 00000000..a47d59da
--- /dev/null
+++ b/Medium/Filter Restaurants by Vegan-Friendly, Price and Distance.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public List<Integer> filterRestaurants(int[][] restaurants, int veganFriendly, int maxPrice, int maxDistance) {
+    List<Integer> indexList = new ArrayList<>();
+    for (int i = 0; i < restaurants.length; i++) {
+      int[] restaurant = restaurants[i];
+      if ((veganFriendly == 0 || restaurant[2] == 1) && restaurant[3] <= maxPrice && restaurant[4] <= maxDistance) {
+        indexList.add(i);
+      }
+    }
+    Collections.sort(indexList, new Comparator<Integer>() {
+      public int compare(Integer o1, Integer o2) {
+        int c = restaurants[o2][1] - restaurants[o1][1];
+        if (c != 0) {
+          return c;
+        }
+        return restaurants[o2][0] - restaurants[o1][0];
+      }
+    });
+    List<Integer> ans = new ArrayList<>();
+    for (Integer index : indexList) {
+      ans.add(restaurants[index][0]);
+    }
+    return ans;
+  }
+}

From b0e07ae7dbaedde4c2c0aa44e30fb44a778d2654 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 2 Feb 2020 20:24:19 -0800
Subject: [PATCH 0090/2175] Added 2 solutions

---
 Easy/The K Weakest Rows in a Matrix.java  | 40 +++++++++++++++++++++++
 Medium/Reduce Array Size to The Half.java | 24 ++++++++++++++
 2 files changed, 64 insertions(+)
 create mode 100644 Easy/The K Weakest Rows in a Matrix.java
 create mode 100644 Medium/Reduce Array Size to The Half.java

diff --git a/Easy/The K Weakest Rows in a Matrix.java b/Easy/The K Weakest Rows in a Matrix.java
new file mode 100644
index 00000000..4da5a15e
--- /dev/null
+++ b/Easy/The K Weakest Rows in a Matrix.java	
@@ -0,0 +1,40 @@
+class Solution {
+  public int[] kWeakestRows(int[][] mat, int k) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < mat.length; i++) {
+      map.put(i, getLastIndex(mat[i], 0, mat[i].length - 1) + 1);
+    }
+    PriorityQueue<Integer> pq = new PriorityQueue<Integer>(new Comparator<Integer>(){
+      public int compare(Integer o1, Integer o2) {
+        int c = map.get(o1) - map.get(o2);
+        if (c != 0) {
+          return c;
+        }
+        return o1 - o2;
+      }
+    });
+    for (int i = 0; i < mat.length; i++) {
+      pq.add(i);
+    }
+    int[] ans = new int[k];
+    for (int i = 0; i < k; i++) {
+      ans[i] = pq.poll();
+    }
+    return ans;
+  }
+  
+  private int getLastIndex(int[] arr, int start, int end) {
+    int idx = -1;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (arr[mid] == 1) {
+        idx = Math.max(idx, mid);
+        start = mid + 1;
+      }
+      else {
+        end = mid - 1;
+      }
+    }
+    return idx;
+  }
+}
diff --git a/Medium/Reduce Array Size to The Half.java b/Medium/Reduce Array Size to The Half.java
new file mode 100644
index 00000000..50c84326
--- /dev/null
+++ b/Medium/Reduce Array Size to The Half.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public int minSetSize(int[] arr) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : arr) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
+      public int compare(Integer o1, Integer o2) {
+        return map.get(o2) - map.get(o1);
+      }
+    });
+    for (Integer key : map.keySet()) {
+      pq.add(key);
+    }
+    int n = arr.length / 2;
+    int currSize = 0;
+    int count = 0;
+    while (currSize < n) {
+      currSize += map.get(pq.poll());
+      count++;
+    }
+    return count;
+  }
+}

From f0fa96979c0510f80ee623d29a34e4e6fe8c77f2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 3 Feb 2020 18:14:13 -0800
Subject: [PATCH 0091/2175] Modified 2 solutions

---
 Easy/Number of Equivalent Domino Pairs.java |  31 +++---
 Medium/Evaluate Division.java               | 107 +++++++-------------
 2 files changed, 58 insertions(+), 80 deletions(-)

diff --git a/Easy/Number of Equivalent Domino Pairs.java b/Easy/Number of Equivalent Domino Pairs.java
index 653043b5..718169ae 100644
--- a/Easy/Number of Equivalent Domino Pairs.java	
+++ b/Easy/Number of Equivalent Domino Pairs.java	
@@ -1,16 +1,23 @@
 class Solution {
-    public int numEquivDominoPairs(int[][] dominoes) {
-        Map<String, Integer> map = new HashMap <>();
-        for (int i = 0; i < dominoes.length; i++) {
-            String key = Math.min(dominoes[i][0], dominoes[i][1]) + "|" + Math.max(dominoes[i][0], dominoes[i][1]);
-            map.put(key, map.getOrDefault(key, 0) + 1);
+  public int numEquivDominoPairs(int[][] dominoes) {
+    int count = 0;
+    Map<String, Integer> map = new HashMap<>();
+    for (int i = 0; i < dominoes.length; i++) {
+      String straightKey = dominoes[i][0] + "/" + dominoes[i][1];
+      String revKey = dominoes[i][1] + "/" + dominoes[i][0];
+      if (map.containsKey(straightKey)) {
+        count += map.get(straightKey);
+      }
+      else if (!straightKey.equals(revKey)) {
+        if (map.containsKey(revKey)) {
+          count += map.get(revKey);
         }
-        
-        int count = 0;
-        for (int value : map.values()) {
-            count += (value * (value - 1)) / 2;
-        }
-        
-        return count;
+      }
+      map.put(straightKey, map.getOrDefault(straightKey, 0) + 1);
+      if (dominoes[i][0] != dominoes[i][1]) {
+        map.put(revKey, map.getOrDefault(revKey, 0) + 1);
+      }
     }
+    return count;
+  }
 }
diff --git a/Medium/Evaluate Division.java b/Medium/Evaluate Division.java
index 76f57b3c..52107a1b 100644
--- a/Medium/Evaluate Division.java	
+++ b/Medium/Evaluate Division.java	
@@ -1,73 +1,44 @@
 class Solution {
-    public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
-        double[] ans = new double[queries.size()];
-
-        Map<String, Set<String>> map = new HashMap<>();
-        Map<String, Double> resMap = new HashMap<>();
-
-        for (int i = 0; i < equations.size(); i++) {
-            String operand1 = equations.get(i).get(0);
-            String operand2 = equations.get(i).get(1);
-
-            map.computeIfAbsent(operand1, k -> new HashSet<>()).add(operand2);
-            map.computeIfAbsent(operand2, k -> new HashSet<>()).add(operand1);
-
-            resMap.put(operand1 + "|" + operand2, values[i]);
-        }
-
-        for (int i = 0; i < queries.size(); i++) {
-            String operand1 = queries.get(i).get(0);
-            String operand2 = queries.get(i).get(1);
-
-            if (!map.containsKey(operand1) || !map.containsKey(operand2)) {
-                ans[i] = -1.0;
-            }
-            else if (operand1.equals(operand2)) {
-                ans[i] = 1.0;
-            }
-            else if (map.get(operand1).contains(operand2)) {
-                ans[i] = getSimpleDivisionVal(resMap, operand1, operand2);
-            }
-            else if (operand2.contains(operand1)) {
-                ans[i] = getSimpleDivisionVal(resMap, operand2, operand1);
-            }
-            else {
-                ans[i] = dfs(map, resMap, operand1, operand2, 1.0, new HashSet<>());
-            }
-        }
-
-        return ans;
+  public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
+    Map<String, List<String>> map = new HashMap<>();
+    Map<String, List<Double>> valueMap = new HashMap<>();
+    for (int i = 0; i < equations.size(); i++) {
+      List<String> equation = equations.get(i);
+      map.computeIfAbsent(equation.get(0), k -> new ArrayList<>()).add(equation.get(1));
+      map.computeIfAbsent(equation.get(1), k -> new ArrayList<>()).add(equation.get(0));
+      valueMap.computeIfAbsent(equation.get(0), k -> new ArrayList<>()).add(values[i]);
+      valueMap.computeIfAbsent(equation.get(1), k -> new ArrayList<>()).add(1 / values[i]);      
     }
-
-    private double dfs (Map<String, Set<String>> map, Map<String, Double> resMap, String operand1, String operand2,
-                        double base, Set<String> visited) {
-        if (visited.contains(operand1)) {
-            return -1.0;
-        }
-        if (map.get(operand1).contains(operand2)) {
-            return base * getSimpleDivisionVal(resMap, operand1, operand2);
-        }
-
-        visited.add(operand1);
-
-        double ans = -1.0;
-        Iterator<String> children = map.get(operand1).iterator();
-
-        while (children.hasNext()) {
-            String child = children.next();
-            if (!visited.contains(child)) {
-                ans = Math.max(ans, dfs(map, resMap, child, operand2, base * getSimpleDivisionVal(resMap, operand1, child), visited));
-            }
-        }
-
-        return ans;
+    double[] ans = new double[queries.size()];
+    for (int i = 0; i < queries.size(); i++) {
+      List<String> query = queries.get(i);
+      ans[i] = dfs(map, valueMap, query.get(0), query.get(1), new HashSet<>(), 1.0);
+      ans[i] = ans[i] == 0.0 ? -1.0 : ans[i];
     }
-
-    private double getSimpleDivisionVal (Map<String, Double> resMap, String operand1, String operand2) {
-        if (resMap.containsKey(operand1 + "|" + operand2)) {
-            return resMap.get(operand1 + "|" + operand2);
-        }
-
-        return 1 / resMap.get(operand2 + "|" + operand1);
+    return ans;
+  }
+  
+  private double dfs(Map<String, List<String>> map, Map<String, List<Double>> valueMap, String a, String b, Set<String> set, double curr) {
+    if (set.contains(a)) {
+      return 0.0;
     }
+    if (!map.containsKey(a)) {
+      return 0.0;
+    }
+    if (a.equals(b)) {
+      return curr;
+    }
+    set.add(a);
+    List<String> children = map.get(a);
+    List<Double> valueList = valueMap.get(a);
+    double temp = 0.0;
+    for (int i = 0; i < children.size(); i++) {
+      temp = dfs(map, valueMap, children.get(i), b, set, curr * valueList.get(i));
+      if (temp != 0.0) {
+        break;
+      }
+    }
+    set.remove(a);
+    return temp;
+  }
 }

From dcbae7612b84f7d422cf8be9abd9f277e4b25dce Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 4 Feb 2020 07:11:52 -0800
Subject: [PATCH 0092/2175] Modified 2 solutions

---
 Easy/Peak Index in a Mountain Array.java | 31 ++++++++++--------------
 Easy/Unique Morse Code Words.java        | 29 +++++++++++-----------
 2 files changed, 27 insertions(+), 33 deletions(-)

diff --git a/Easy/Peak Index in a Mountain Array.java b/Easy/Peak Index in a Mountain Array.java
index a72454fd..818dbf9c 100644
--- a/Easy/Peak Index in a Mountain Array.java	
+++ b/Easy/Peak Index in a Mountain Array.java	
@@ -1,21 +1,16 @@
 class Solution {
-	public int peakIndexInMountainArray(int[] A) {
-        return peakIndexInMountainArrayImpl(A, 0, A.length-1);
+  public int peakIndexInMountainArray(int[] A) {
+    int low = 0;
+    int high = A.length - 1;
+    while (low < high) {
+      int mid = low + (high - low) / 2;
+      if (A[mid] < A[mid + 1]) {
+        low = mid + 1;
+      }
+      else {
+        high = mid;
+      }
     }
-	
-	private int peakIndexInMountainArrayImpl(int[] arr, int start, int end) {
-		if (start > end) return -1;
-		
-		int mid = (start + end)/2;
-		
-		if (arr[mid] > arr[mid-1] && arr[mid] > arr[mid+1]) {
-			return mid;
-		}
-		else if (arr[mid] < arr[mid-1]) {
-			return peakIndexInMountainArrayImpl(arr, start, mid-1);
-		}
-		else {
-			return peakIndexInMountainArrayImpl(arr, mid+1, end);
-		}
-	}
+    return low;
+  }
 }
diff --git a/Easy/Unique Morse Code Words.java b/Easy/Unique Morse Code Words.java
index b6206351..2db49a03 100644
--- a/Easy/Unique Morse Code Words.java	
+++ b/Easy/Unique Morse Code Words.java	
@@ -1,18 +1,17 @@
 class Solution {
-    public static int uniqueMorseRepresentations(String[] words) {
-        String[] codes = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
-        Set<String> set = new HashSet<>();
-
-        for (String word : words) {
-            StringBuilder sb = new StringBuilder();
-
-            for (char c : word.toCharArray()) {
-                sb.append(codes[c-'a']);
-            }
-
-            set.add(sb.toString());
-        }
-
-        return set.size();
+  public int uniqueMorseRepresentations(String[] words) {
+    String[] morseCodes = {
+      ".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",
+      ".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."
+    };
+    Set<String> set = new HashSet<>();
+    for (String word : words) {
+      StringBuilder sb = new StringBuilder();
+      for (char c : word.toCharArray()) {
+        sb.append(morseCodes[c - 'a']);
+      }
+      set.add(sb.toString());
     }
+    return set.size();
+  }
 }

From 2cc697f90c670ecc1bec05d991c824a691b77b2d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 4 Feb 2020 20:17:37 -0800
Subject: [PATCH 0093/2175] Modified 3 solutions

---
 Easy/Majority Element.java      | 13 +++++
 Easy/Rotate String.java         | 10 ++--
 Easy/majority_element.java      | 21 --------
 Medium/Majority Element II.java | 96 +++++++++++++++------------------
 4 files changed, 59 insertions(+), 81 deletions(-)
 create mode 100644 Easy/Majority Element.java
 delete mode 100644 Easy/majority_element.java

diff --git a/Easy/Majority Element.java b/Easy/Majority Element.java
new file mode 100644
index 00000000..3c2b580c
--- /dev/null
+++ b/Easy/Majority Element.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int majorityElement(int[] nums) {
+    int count = 0;
+    Integer candidate = null;
+    for (int num : nums) {
+      if (count == 0) {
+        candidate = num;
+      }
+      count += num == candidate ? 1 : -1;
+    }
+    return candidate;
+  }
+}
diff --git a/Easy/Rotate String.java b/Easy/Rotate String.java
index 38b31492..57f540ac 100644
--- a/Easy/Rotate String.java	
+++ b/Easy/Rotate String.java	
@@ -1,9 +1,5 @@
 class Solution {
-    public boolean rotateString(String A, String B) {
-        if (A.length() != B.length()) {
-            return false;
-        }
-        
-        return (A + A).contains(B);
-    }
+  public boolean rotateString(String A, String B) {
+    return A.length() == B.length() && (A + A).indexOf(B) != -1;
+  }
 }
diff --git a/Easy/majority_element.java b/Easy/majority_element.java
deleted file mode 100644
index 20e4362a..00000000
--- a/Easy/majority_element.java
+++ /dev/null
@@ -1,21 +0,0 @@
-import java.util.ArrayList;
-public class Solution {
-    public int majorityElement(int[] num) 
-	{
-	int major = num[0];
-	int appears = 1;
-
-	for (int i = 1, count = num.length; i < count; ++i){
-		if (num[i] == major) {
-			appears ++;
-		} else if (appears == 0) {
-			appears ++;
-			major = num[i];
-		} else {
-			appears --;
-		}
-	}
-
-	return major;
-    }
-}
\ No newline at end of file
diff --git a/Medium/Majority Element II.java b/Medium/Majority Element II.java
index dcbe0102..291b6f57 100644
--- a/Medium/Majority Element II.java	
+++ b/Medium/Majority Element II.java	
@@ -1,56 +1,46 @@
 class Solution {
-    public List<Integer> majorityElement(int[] nums) {
-        if (nums.length == 0) {
-            return new ArrayList<>();
-        }
-        
-        int num1 = nums[0];
-        int num2 = nums[0];
-        int count1 = 0;
-        int count2 = 0;
-        
-        for (int i = 0; i < nums.length; i++) {
-            if (nums[i] == num1) {
-                count1++;
-            }
-            else if (nums[i] == num2) {
-                count2++;
-            }
-            else if (count1 == 0) {
-                num1 = nums[i];
-                count1 = 1;
-            }
-            else if (count2 == 0) {
-                num2 = nums[i];
-                count2 = 1;
-            }
-            else {
-                count1--;
-                count2--;
-            }
-        }
-        
-        count1 = 0;
-        count2 = 0;
-        
-        for (int i = 0; i< nums.length; i++) {
-            if (nums[i] == num1) {
-                count1++;
-            }
-            else if (nums[i] == num2) {
-                count2++;
-            }
-        }
-        
-        List<Integer> ans = new ArrayList<>();
-        if (count1 > nums.length / 3) {
-            ans.add(num1);
-        }
-        
-        if (count2 > nums.length / 3) {
-            ans.add(num2);
-        }
-        
-        return ans;
+  public List<Integer> majorityElement(int[] nums) {
+    int count1 = 0;
+    int count2 = 0;
+    Integer candidate1 = null;
+    Integer candidate2 = null;
+    for (int num : nums) {
+      if (candidate1 != null && candidate1 == num) {
+        count1++; 
+      }
+      else if (candidate2 != null && candidate2 == num) {
+        count2++;
+      }
+      else if (count1 == 0) {
+        candidate1 = num;
+        count1 = 1;
+      }
+      else if (count2 == 0) {
+        candidate2 = num;
+        count2 = 1;
+      }
+      else {
+        count1--;
+        count2--;
+      }
     }
+    List<Integer> ans = new ArrayList<>();
+    count1 = 0;
+    count2 = 0;
+    for (int num : nums) {
+      if (candidate1 != null && candidate1 == num) {
+        count1++;
+      }
+      else if (candidate2 != null && candidate2 == num) {
+        count2++;
+      }
+    }
+    if (count1 > nums.length / 3) {
+      ans.add(candidate1);
+    }
+    if (count2 > nums.length / 3) {
+      ans.add(candidate2);
+    }
+    return ans;
+  }
 }

From d886046a59624c1bd48dc51c901dba4748753583 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 5 Feb 2020 06:56:05 -0800
Subject: [PATCH 0094/2175] Modified 2 solutions

---
 Easy/Array Partition I.java | 23 +++++++++++------
 Easy/Count and Say.java     | 49 +++++++++++++++----------------------
 2 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/Easy/Array Partition I.java b/Easy/Array Partition I.java
index cb082777..8e6012c2 100644
--- a/Easy/Array Partition I.java	
+++ b/Easy/Array Partition I.java	
@@ -1,11 +1,20 @@
 class Solution {
-    public int arrayPairSum(int[] nums) {
-        Arrays.sort(nums);
-        int sum = 0;
-        for (int i = 0; i < nums.length; i += 2) {
-            sum += nums[i];
+  public int arrayPairSum(int[] nums) {
+    int[] arr = new int[20001];
+    for (int num : nums) {
+      arr[num + 10000]++;
+    }
+    int sum = 0;
+    boolean odd = true;
+    for (int i = 0; i < arr.length; i++) {
+      while (arr[i] > 0) {
+        if (odd) {
+          sum += i - 10000;
         }
-        
-        return sum;
+        odd = !odd;
+        arr[i]--;
+      }
     }
+    return sum;
+  }
 }
diff --git a/Easy/Count and Say.java b/Easy/Count and Say.java
index 8fd83c74..7f2eed96 100644
--- a/Easy/Count and Say.java	
+++ b/Easy/Count and Say.java	
@@ -1,32 +1,23 @@
 class Solution {
-    public String countAndSay(int n) {
-        String first = "1";
-        String str = "11";
-        
-        if (n == 1) return first;
-        if (n == 2) return str;
-        
-        for (int i = 3; i<=n; i++) {
-            str += "$";
-            int len = str.length();
-
-            int cnt = 1; 
-            String  tmp = ""; 
-            
-            for (int j = 1; j < len; j++) {
-                if (str.charAt(j) != str.charAt(j-1)) {
-                    tmp += String.valueOf(cnt);
-                    tmp += str.charAt(j-1);
-
-                    cnt = 1;
-                }
-
-                else cnt++;
-            }
-
-            str = tmp;
-        }
-        
-        return str;
+  public String countAndSay(int n) {
+    return rec(n, "1");
+  }
+  
+  private String rec(int n, String s) {
+    if (n == 1) {
+      return s;
     }
+    StringBuilder sb = new StringBuilder();
+    int idx = 0;
+    while (idx < s.length()) {
+      char c = s.charAt(idx);
+      int count = 0;
+      while (idx < s.length() && s.charAt(idx) == c) {
+        idx++;
+        count++;
+      }
+      sb.append(count).append(c);
+    }
+    return rec(n - 1, sb.toString());
+  }
 }

From 743bba84e9abddd849d0fde309a4532eea5b51fe Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 5 Feb 2020 19:03:14 -0800
Subject: [PATCH 0095/2175] Modified 3 solutions

---
 Easy/Add Strings.java               | 52 +++++++++++++----------------
 Easy/Palindrome Number.java         | 24 +++++++------
 Easy/Trim a Binary Search Tree.java | 24 ++++++++-----
 3 files changed, 52 insertions(+), 48 deletions(-)

diff --git a/Easy/Add Strings.java b/Easy/Add Strings.java
index 7f91e6e1..f229760b 100644
--- a/Easy/Add Strings.java	
+++ b/Easy/Add Strings.java	
@@ -1,31 +1,27 @@
 class Solution {
-    public String addStrings(String num1, String num2) {
-        StringBuilder sb = new StringBuilder();
-        int idx1 = num1.length() - 1;
-        int idx2 = num2.length() - 1;
-        int carry = 0;
-        
-        while (idx1 >= 0 || idx2 >= 0) {
-            int temp = carry;
-            if (idx1 >= 0 && idx2 >= 0) {
-                temp += (num1.charAt(idx1) - '0') + (num2.charAt(idx2) - '0');
-            }
-            else if (idx1 >= 0 && idx2 < 0) {
-                temp += (num1.charAt(idx1) - '0');
-            }
-            else {
-                temp += (num2.charAt(idx2) - '0');
-            }
-            
-            carry = temp > 9 ? temp / 10 : 0;
-            temp = temp > 9 ? temp % 10 : temp;
-            sb.append(temp); 
-            idx1--;
-            idx2--;
-        }
-        
-        sb.append(carry > 0 ? carry : "");
-        
-        return sb.reverse().toString();
+  public String addStrings(String num1, String num2) {
+    StringBuilder sb = new StringBuilder();
+    int idx1 = num1.length() - 1;
+    int idx2 = num2.length() - 1;
+    int carry = 0;
+    while (idx1 >= 0 || idx2 >= 0) {
+      int temp = carry;
+      if (idx1 >= 0 && idx2 >= 0) {
+        temp += Character.getNumericValue(num1.charAt(idx1--)) + Character.getNumericValue(num2.charAt(idx2--));
+      }
+      else if (idx1 >= 0 && idx2 < 0) {
+        temp += Character.getNumericValue(num1.charAt(idx1--));
+      }
+      else {
+        temp += Character.getNumericValue(num2.charAt(idx2--));
+      }
+      carry = temp > 9 ? 1 : 0;
+      temp = temp > 9 ? temp % 10 : temp;
+      sb.append(temp);
     }
+    if (carry > 0) {
+      sb.append(carry);
+    }
+    return sb.reverse().toString();
+  }
 }
diff --git a/Easy/Palindrome Number.java b/Easy/Palindrome Number.java
index 54341864..6c5be699 100644
--- a/Easy/Palindrome Number.java	
+++ b/Easy/Palindrome Number.java	
@@ -1,15 +1,17 @@
 class Solution {
-    public boolean isPalindrome(int x) {
-        return x < 0 ? false : x == getReverseDigit(x);
+  public boolean isPalindrome(int x) {
+    if (x < 0) {
+      return false;
     }
-    
-    private int getReverseDigit(int x) {
-        int num = 0;
-        while (x > 0) {
-            num = num * 10 + x % 10;
-            x /= 10;
-        }
-        
-        return num;
+    return x - reverse(x) == 0;
+  }
+  
+  private int reverse(int n) {
+    int newNum = 0;
+    while (n > 0) {
+      newNum = newNum * 10 + n % 10;
+      n /= 10;
     }
+    return newNum;
+  }
 }
diff --git a/Easy/Trim a Binary Search Tree.java b/Easy/Trim a Binary Search Tree.java
index 4c3e6a74..b596e6b2 100644
--- a/Easy/Trim a Binary Search Tree.java	
+++ b/Easy/Trim a Binary Search Tree.java	
@@ -8,14 +8,20 @@
  * }
  */
 class Solution {
-    public TreeNode trimBST(TreeNode root, int L, int R) {
-        if (root == null) return null;
-        if (root.val < L) return trimBST(root.right, L, R);
-        if (root.val > R) return trimBST(root.left, L, R);
-        
-        root.left = trimBST(root.left, L, R);
-        root.right = trimBST(root.right, L, R);
-        
-        return root;
+  public TreeNode trimBST(TreeNode root, int L, int R) {
+    if (root == null) {
+      return null;
     }
+    if (root.val < L) {
+      return trimBST(root.right, L, R);
+    }
+    else if (root.val > R) {
+      return trimBST(root.left, L, R);
+    }
+    else {
+      root.left = trimBST(root.left, L, R);
+      root.right = trimBST(root.right, L, R);
+      return root;
+    }
+  }
 }

From ee9d31ebb83f427e955c39c30fd36243e4fc44fc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 6 Feb 2020 07:26:08 -0800
Subject: [PATCH 0096/2175] Added one solution & modified 2 solutions

---
 Easy/Day of the Week.java              | 30 ++++++++++++
 Easy/Fibonacci Numbers.java            | 38 +++++++--------
 Easy/Implement Queue using Stacks.java | 65 +++++++++++++++-----------
 3 files changed, 83 insertions(+), 50 deletions(-)
 create mode 100644 Easy/Day of the Week.java

diff --git a/Easy/Day of the Week.java b/Easy/Day of the Week.java
new file mode 100644
index 00000000..026f91cd
--- /dev/null
+++ b/Easy/Day of the Week.java	
@@ -0,0 +1,30 @@
+class Solution {
+    int[] m = {0,31,28,31,30,31,30,31,31,30,31,30,31};
+    String[] res = {"Friday", "Saturday", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday"};
+    public String dayOfTheWeek(int day, int month, int year) {
+      int days = years(year);
+      if(isLeap(year))
+        m[2] = 29;
+      for(int i=0; i < month; i++){
+        days += m[i];
+      }
+      days += day-1;
+      return res[days%7];
+    }
+    private int years(int y){
+      int count = 0;
+      for(int i=1971; i < y; i++){
+        if(isLeap(i))
+         count += 366;    
+        else
+         count += 365;    
+      }
+      return count;
+    }
+    private boolean isLeap(int y){
+      if(y % 4 != 0) return false;
+      else if(y%100 != 0) return true;
+      else if(y % 400 != 0) return false;
+      else return true;
+    }
+}
diff --git a/Easy/Fibonacci Numbers.java b/Easy/Fibonacci Numbers.java
index 3709df55..f5e33e3b 100644
--- a/Easy/Fibonacci Numbers.java	
+++ b/Easy/Fibonacci Numbers.java	
@@ -1,26 +1,20 @@
 class Solution {
-    int[] arr;
-    public int fib(int N) {
-        arr = new int[N + 1];
-        return fibHelper(N);
+  public int fib(int N) {
+    Integer[] memo = new Integer[N + 1];
+    return getFib(memo, N);
+  }
+  
+  private int getFib(Integer[] memo, int N) {
+    if (memo[N] != null) {
+      return memo[N];
     }
-    
-    private int fibHelper(int N) {
-        if (N == 0) {
-            return 0;
-        }
-        
-        if (N == 1) {
-            arr[1] = 1;
-            return 1;
-        }
-        
-        if (arr[N] != 0) {
-            return arr[N];
-        }
-        
-        arr[N] = fibHelper(N - 1) + fibHelper(N - 2);
-        
-        return arr[N];
+    else if (N == 0) {
+      return 0;
     }
+    else if (N == 1) {
+      return 1;
+    }
+    memo[N] = getFib(memo, N - 1) + getFib(memo, N - 2);
+    return memo[N];
+  }
 }
diff --git a/Easy/Implement Queue using Stacks.java b/Easy/Implement Queue using Stacks.java
index d42922a9..c2a5254d 100644
--- a/Easy/Implement Queue using Stacks.java	
+++ b/Easy/Implement Queue using Stacks.java	
@@ -1,37 +1,46 @@
 class MyQueue {
 
-    /** Initialize your data structure here. */
-    Stack<Integer> oldStack = new Stack<>();
-    Stack<Integer> newStack = new Stack<>();
-    
-    /** Push element x to the back of queue. */
-    public void push(int x) {
-        while (!newStack.isEmpty()) {
-            oldStack.push(newStack.pop());
-        }
-        oldStack.push(x);
+  /** Initialize your data structure here. */
+  Stack<Integer> stack;
+  Stack<Integer> revStack;
+  public MyQueue() {
+    stack = new Stack<>();
+    revStack = new Stack<>();
+  }
+
+  /** Push element x to the back of queue. */
+  public void push(int x) {
+    stack.push(x);
+  }
+
+  /** Removes the element from in front of queue and returns that element. */
+  public int pop() {
+    while (!stack.isEmpty()) {
+      revStack.push(stack.pop());
     }
-    
-    /** Removes the element from in front of queue and returns that element. */
-    public int pop() {
-        while (!oldStack.isEmpty()) {
-            newStack.push(oldStack.pop());
-        }
-        return newStack.pop();
+    int num = revStack.pop();
+    while (!revStack.isEmpty()) {
+      stack.push(revStack.pop());
     }
-    
-    /** Get the front element. */
-    public int peek() {
-        while (!oldStack.isEmpty()) {
-            newStack.push(oldStack.pop());
-        }
-        return newStack.peek();
+    return num;
+  }
+
+  /** Get the front element. */
+  public int peek() {
+    while (!stack.isEmpty()) {
+      revStack.push(stack.pop());
     }
-    
-    /** Returns whether the queue is empty. */
-    public boolean empty() {
-        return oldStack.isEmpty() && newStack.isEmpty();
+    int num = revStack.peek();
+    while (!revStack.isEmpty()) {
+      stack.push(revStack.pop());
     }
+    return num;
+  }
+
+  /** Returns whether the queue is empty. */
+  public boolean empty() {
+    return stack.isEmpty();
+  }
 }
 
 /**

From 2692273d9d978d63a1a19a9397eb37b1c6c952f9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 7 Feb 2020 07:22:07 -0800
Subject: [PATCH 0097/2175] Modified one solution

---
 ...ords That Can Be Formed by Characters.java | 54 +++++++++----------
 1 file changed, 25 insertions(+), 29 deletions(-)

diff --git a/Easy/Find Words That Can Be Formed by Characters.java b/Easy/Find Words That Can Be Formed by Characters.java
index 80a78c5a..46d11d0f 100644
--- a/Easy/Find Words That Can Be Formed by Characters.java	
+++ b/Easy/Find Words That Can Be Formed by Characters.java	
@@ -1,33 +1,29 @@
 class Solution {
-    public int countCharacters(String[] words, String chars) {
-        int goodWordsLength = 0;
-        Map<Character, Integer> charsMap = getMap(chars);
-
-        for (String word : words) {
-            Map<Character, Integer> wordMap = getMap(word);
-            boolean allFound = true;
-            for (Character character : wordMap.keySet()) {
-                if (charsMap.getOrDefault(character, 0) < wordMap.get(character)) {
-                    allFound = false;
-                    break;
-                }
-            }
-
-            if (allFound) {
-                goodWordsLength +=word.length();
-            }
-        }
-
-
-        return goodWordsLength;
+  public int countCharacters(String[] words, String chars) {
+    Map<Character, Integer> charFreq = getMap(chars);
+    int length = 0;
+    for (String word : words) {
+      if (canBeFormed(charFreq, getMap(word))) {
+        length += word.length();
+      }
     }
-
-    private Map<Character, Integer> getMap(String s) {
-        Map<Character, Integer> map = new HashMap<>();
-        for (char c : s.toCharArray()) {
-            map.put(c, map.getOrDefault(c, 0) + 1);
-        }
-
-        return map;
+    return length;
+  }
+  
+  private Map<Character, Integer> getMap(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      map.put(c, map.getOrDefault(c, 0) + 1);
     }
+    return map;
+  }
+  
+  private boolean canBeFormed(Map<Character, Integer> main, Map<Character, Integer> toBeChecked) {
+    for (Character key : toBeChecked.keySet()) {
+      if (main.getOrDefault(key, 0) < toBeChecked.get(key)) {
+        return false;
+      }
+    }
+    return true;
+  }
 }

From af8456174636d5388f7496e09546d94785290508 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 9 Feb 2020 08:42:58 -0800
Subject: [PATCH 0098/2175] Added 2 solutions

---
 Easy/Check If N and Its Double Exist.java         | 12 ++++++++++++
 ...umber of Steps to Reduce a Number to Zero.java | 15 +++++++++++++++
 2 files changed, 27 insertions(+)
 create mode 100644 Easy/Check If N and Its Double Exist.java
 create mode 100644 Easy/Number of Steps to Reduce a Number to Zero.java

diff --git a/Easy/Check If N and Its Double Exist.java b/Easy/Check If N and Its Double Exist.java
new file mode 100644
index 00000000..a7af36ea
--- /dev/null
+++ b/Easy/Check If N and Its Double Exist.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public boolean checkIfExist(int[] arr) {
+    Set<Integer> set = new HashSet<>();
+    for (Integer num : arr) {
+      if (set.contains(num * 2) || (num % 2 == 0 && set.contains(num / 2))) {
+        return true;
+      }
+      set.add(num);
+    }
+    return false;
+  }
+}
diff --git a/Easy/Number of Steps to Reduce a Number to Zero.java b/Easy/Number of Steps to Reduce a Number to Zero.java
new file mode 100644
index 00000000..279fcfee
--- /dev/null
+++ b/Easy/Number of Steps to Reduce a Number to Zero.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int numberOfSteps (int num) {
+    int count = 0;
+    while (num > 0) {
+      if (num % 2 == 0) {
+        num /= 2;
+      }
+      else {
+        num--;
+      }
+      count++;
+    }
+    return count;
+  }
+}

From 1156d038ce0843a51e5862b84cd895e4e28252c2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 11 Feb 2020 07:10:40 -0800
Subject: [PATCH 0099/2175] Added 2 solutions & modified 1 solution

---
 Easy/Student Attendance Record I.java         | 26 +++++-----
 Medium/Network Delay Time.java                | 49 +++++++++++++++++++
 ...ge Greater than or Equal to Threshold.java | 17 +++++++
 3 files changed, 78 insertions(+), 14 deletions(-)
 create mode 100644 Medium/Network Delay Time.java
 create mode 100644 Medium/Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold.java

diff --git a/Easy/Student Attendance Record I.java b/Easy/Student Attendance Record I.java
index 2cef111b..0278cb49 100644
--- a/Easy/Student Attendance Record I.java	
+++ b/Easy/Student Attendance Record I.java	
@@ -1,18 +1,16 @@
 class Solution {
-    public boolean checkRecord(String s) {
-        int absCount = 0;
-        if (s.contains("LLL")) {
-            return false;
+  public boolean checkRecord(String s) {
+    int absentCount = 0;
+    for (int i = 0; i< s.length(); i++) {
+      if (s.charAt(i) == 'A') {
+        absentCount++;
+      }
+      else if (s.charAt(i) == 'L') {
+        if (i + 1 < s.length() && i + 2 < s.length() && s.charAt(i + 1) == 'L' && s.charAt(i + 2) == 'L') {
+          return false;
         }
-        
-        for (int i=0;i<s.length();i++) {
-            if (s.charAt(i) == 'A') {
-                absCount++;
-            }
-            if (absCount>1) {
-                return false;
-            } 
-        }
-        return true;
+      }
     }
+    return absentCount <= 1;
+  }
 }
diff --git a/Medium/Network Delay Time.java b/Medium/Network Delay Time.java
new file mode 100644
index 00000000..d1dc03be
--- /dev/null
+++ b/Medium/Network Delay Time.java	
@@ -0,0 +1,49 @@
+class Solution {
+  public int networkDelayTime(int[][] times, int N, int K) {
+    Map<Integer, List<Connection>> map = new HashMap<>();
+    for (int[] time : times) {
+      map.computeIfAbsent(time[0], k -> new ArrayList<>()).add(new Connection(time[1], time[2]));
+    }
+    Map<Integer, Integer> dist = new HashMap<>();
+    for (int node = 1; node <= N; node++) {
+      dist.put(node, Integer.MAX_VALUE);
+    }
+    dist.put(K, 0);
+    boolean[] seen = new boolean[N + 1];
+    while (true) {
+      int candNode = -1;
+      int candDist = Integer.MAX_VALUE;
+      for (int i = 1; i <= N; ++i) {
+        if (!seen[i] && dist.get(i) < candDist) {
+          candDist = dist.get(i);
+          candNode = i;
+        }
+      }
+      if (candNode < 0) {
+        break;
+      }
+      seen[candNode] = true;
+      for (Connection con: map.getOrDefault(candNode, new ArrayList<>())) {
+        dist.put(con.val, Math.min(dist.get(con.val), dist.get(candNode) + con.time));
+      }
+    }
+    int ans = 0;
+    for (int cand: dist.values()) {
+      if (cand == Integer.MAX_VALUE) {
+        return -1;
+      }
+      ans = Math.max(ans, cand);
+    }
+    return ans;
+  }
+}
+
+class Connection {
+  int val;
+  int time;
+  
+  public Connection(int val, int time) {
+    this.val = val;
+    this.time = time;
+  }
+}
diff --git a/Medium/Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold.java b/Medium/Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold.java
new file mode 100644
index 00000000..d2305c14
--- /dev/null
+++ b/Medium/Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int numOfSubarrays(int[] arr, int k, int threshold) {
+    int sum = 0;
+    int start = 0;
+    int count = 0;
+    for (int i = 0; i < arr.length; i++) {
+      sum += arr[i];
+      if (i - start + 1 == k) {
+        if ((double) sum / k >= threshold) {
+          count++;
+        }
+        sum -= arr[start++]; 
+      }
+    }
+    return count;
+  }
+}

From 8c852c307e899f6735517cb8ac896b0424f312a6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 11 Feb 2020 21:07:33 -0800
Subject: [PATCH 0100/2175] Added 1 solution & modified 1 solution

---
 Easy/Increasing Order Search Tree.java | 44 ++++++++++----------------
 Easy/Leaf Similar Tree.java            | 31 ++++++++++++++++++
 2 files changed, 48 insertions(+), 27 deletions(-)
 create mode 100644 Easy/Leaf Similar Tree.java

diff --git a/Easy/Increasing Order Search Tree.java b/Easy/Increasing Order Search Tree.java
index c4a487b7..4039276d 100644
--- a/Easy/Increasing Order Search Tree.java	
+++ b/Easy/Increasing Order Search Tree.java	
@@ -8,32 +8,22 @@
  * }
  */
 class Solution {
-    
-    public List<TreeNode> list = new ArrayList<>();
-    public TreeNode increasingBST(TreeNode root) {
-        inorderTraversal(root);
-        
-        if (list.size() == 0) return null;
-        
-        TreeNode ans = list.get(0);
-        TreeNode curr = ans;
-        
-        for (int i=1; i<list.size(); i++) {
-            curr.right = list.get(i);
-            curr.left = null;
-            curr = curr.right;
-        }
-        
-        curr.left = null;
-        
-        return ans;
-    }
-    
-    public void inorderTraversal(TreeNode root) {
-        if (root == null) return;
-        
-        inorderTraversal(root.left);
-        list.add(root);
-        inorderTraversal(root.right);
+  TreeNode curr;
+  public TreeNode increasingBST(TreeNode root) {
+    TreeNode ans = new TreeNode(-1);
+    curr = ans;
+    inorder(root);
+    return ans.right;
+  }
+  
+  private void inorder(TreeNode node) {
+    if (node == null) {
+      return;
     }
+    inorder(node.left);
+    node.left = null;
+    curr.right = node;
+    curr = node;
+    inorder(node.right);
+  }
 }
diff --git a/Easy/Leaf Similar Tree.java b/Easy/Leaf Similar Tree.java
new file mode 100644
index 00000000..8124e3f7
--- /dev/null
+++ b/Easy/Leaf Similar Tree.java	
@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+    List<Integer> leaf1 = new ArrayList<>();
+    List<Integer> leaf2 = new ArrayList<>();
+    populateLeaves(root1, leaf1);
+    populateLeaves(root2, leaf2);
+    return leaf1.equals(leaf2);
+  }
+  
+  private void populateLeaves(TreeNode root, List<Integer> list) {
+    if (root == null) {
+      return;
+    }
+    if (root.left == null && root.right == null) {
+      list.add(root.val);
+    }
+    else {
+      populateLeaves(root.left, list);
+      populateLeaves(root.right, list);
+    }
+  }
+}

From 8eaa969da3a14c4d5db40aefe1187dea511203fc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 12 Feb 2020 07:57:46 -0800
Subject: [PATCH 0101/2175] Modified 2 solutions

---
 Easy/Employee Importance.java                 | 33 +++++------
 .../Find Largest Value in Each Tree Row.java  | 35 ++++++++++++
 Medium/Find Largest Value in Tree Row.java    | 55 -------------------
 3 files changed, 49 insertions(+), 74 deletions(-)
 create mode 100644 Medium/Find Largest Value in Each Tree Row.java
 delete mode 100644 Medium/Find Largest Value in Tree Row.java

diff --git a/Easy/Employee Importance.java b/Easy/Employee Importance.java
index cb405d7b..9a1a046e 100644
--- a/Easy/Employee Importance.java	
+++ b/Easy/Employee Importance.java	
@@ -11,25 +11,20 @@ class Employee {
 };
 */
 class Solution {
-    
-    public int getImportance(List<Employee> employees, int id) {
-        Map<Integer, Employee> map = new HashMap<>();
-        
-        for (int i=0;i<employees.size(); i++) {
-            map.put(employees.get(i).id, employees.get(i));
-        }
-        
-        return solver(map, id);
+  public int getImportance(List<Employee> employees, int id) {
+    Map<Integer, Employee> map = new HashMap<>();
+    for (Employee employee : employees) {
+      map.put(employee.id, employee);
     }
-    
-    public int solver(Map<Integer, Employee> map, int id) {
-        Employee main = map.get(id);
-        int total = main.importance;
-        
-        for(int s : main.subordinates) {
-            total += solver(map, s);
-        }
-        
-        return total;
+    return dfs(map, id);
+  }
+  
+  private int dfs(Map<Integer, Employee> map, int id) {
+    Employee employee = map.get(id);
+    int importance = employee.importance;
+    for (Integer sub : employee.subordinates) {
+      importance += dfs(map, sub);
     }
+    return importance;
+  }
 }
diff --git a/Medium/Find Largest Value in Each Tree Row.java b/Medium/Find Largest Value in Each Tree Row.java
new file mode 100644
index 00000000..49aeca0e
--- /dev/null
+++ b/Medium/Find Largest Value in Each Tree Row.java	
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  public List<Integer> largestValues(TreeNode root) {
+    List<Integer> list = new ArrayList<>();
+    if (root == null) {
+      return list;
+    }
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int maxVal = Integer.MIN_VALUE;
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        maxVal = Math.max(maxVal, removed.val);
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+      list.add(maxVal);
+    }
+    return list;
+  }
+}
diff --git a/Medium/Find Largest Value in Tree Row.java b/Medium/Find Largest Value in Tree Row.java
deleted file mode 100644
index 6c0d432a..00000000
--- a/Medium/Find Largest Value in Tree Row.java	
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    
-    public List<Integer> largestValues(TreeNode root) {
-        
-        List<Integer> ans = new ArrayList<>();
-        
-        if (root == null) return ans;
-        
-        ArrayList<TreeNode> arr = new ArrayList<>();
-        arr.add(root);
-        
-        while (arr.size() != 0) {
-            ArrayList<TreeNode> roots = new ArrayList<>();
-            ArrayList<Integer> a = new ArrayList<>();
-            
-            int i = 0;
-            
-            while (i < arr.size()) {
-                TreeNode p = arr.get(i);
-                if (p.left != null) {
-                    roots.add(p.left);
-                }
-                if (p.right != null) {
-                    roots.add(p.right);
-                }
-                
-                a.add(p.val);
-                
-                i++;
-            }
-
-            Collections.sort(a);
-            
-            ans.add(a.get(a.size()-1));
-            arr.clear();
-            
-            i = 0;
-            while(i < roots.size()) {
-                arr.add(roots.get(i));
-                i++;
-            }
-        }
-        
-        return ans;
-    }
-}

From 91c7533a24c0e1d1ef052662093e87547d3a86d7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 13 Feb 2020 07:31:33 -0800
Subject: [PATCH 0102/2175] Modified 2 solutions

---
 Easy/Binary Tree Paths.java      | 42 +++++++++---------
 Easy/Cousins in Binary Tree.java | 73 ++++++++++++++------------------
 2 files changed, 53 insertions(+), 62 deletions(-)

diff --git a/Easy/Binary Tree Paths.java b/Easy/Binary Tree Paths.java
index af9298bc..08dfef94 100644
--- a/Easy/Binary Tree Paths.java	
+++ b/Easy/Binary Tree Paths.java	
@@ -8,26 +8,28 @@
  * }
  */
 class Solution {
-    public List<String> binaryTreePaths(TreeNode root) {
-        List<String> list = new ArrayList<>();
-        if (root != null) {
-            getString(root, "", list);
-        }
-        
-        return list;
+  List<String> list;
+  public List<String> binaryTreePaths(TreeNode root) {
+    list = new ArrayList<>();
+    if (root == null) {
+      return list;
     }
-    
-    public void getString(TreeNode root, String s, List<String> list) {
-        if (root.left == null && root.right == null) {
-            list.add(s + root.val);
-        }
-        
-        if (root.left != null) {
-            getString(root.left, s + root.val + "->", list);
-        }
-        
-        if (root.right != null) {
-            getString(root.right, s + root.val + "->", list);
-        }
+    helper(root, new StringBuilder());
+    return list;
+  }
+  
+  private void helper(TreeNode root, StringBuilder sb) {
+    if (root == null) {
+      return;
     }
+    if (root.left == null && root.right == null) {
+      sb.append(root.val);
+      list.add(sb.toString());
+    }
+    else {
+      sb.append(root.val).append("->");
+      helper(root.left, new StringBuilder(sb.toString()));
+      helper(root.right, new StringBuilder(sb.toString()));
+    }
+  }
 }
diff --git a/Easy/Cousins in Binary Tree.java b/Easy/Cousins in Binary Tree.java
index fdedb1c5..5b12a341 100644
--- a/Easy/Cousins in Binary Tree.java	
+++ b/Easy/Cousins in Binary Tree.java	
@@ -8,49 +8,38 @@
  * }
  */
 class Solution {
-    public boolean isCousins(TreeNode root, int x, int y) {
-        if (root == null) {
-            return false;
-        }
-        
-        DetailedNode nodeX = helper(root, null, x, 0);
-        DetailedNode nodeY = helper(root, null, y, 0);
-        
-        if (nodeX == null || nodeY == null) {
-            return false;
-        }
-        
-        return nodeX.depth == nodeY.depth && nodeX.parent != nodeY.parent;
+  public boolean isCousins(TreeNode root, int x, int y) {
+    if (root == null || x == y) {
+      return true;
     }
-    
-    private DetailedNode helper(TreeNode root, TreeNode parent, int num, int depth) {
-        if (root == null) {
-            return null;
-        }
-        
-        if (root.val == num) {
-            return new DetailedNode(root, parent, depth - 1);
-        }
-        
-        DetailedNode left = helper(root.left, root, num, depth + 1);
-        DetailedNode right = helper(root.right, root, num, depth + 1);
-        
-        if (left == null) {
-            return right;
-        }
-        
-        return left;
+    ParentData p1 = new ParentData();
+    ParentData p2 = new ParentData();
+    helper(root, x, 0, null, p1);
+    helper(root, y, 0, null, p2);
+    return p1.depth == p2.depth && p1.parent != p2.parent;
+  }
+  
+  private void helper(TreeNode root, int x, int currDepth, TreeNode parent, ParentData p) {
+    if (root == null) {
+      return;
     }
-    
-    class DetailedNode {
-        public TreeNode node;
-        public TreeNode parent;
-        public int depth;
-        
-        public DetailedNode(TreeNode node, TreeNode parent, int depth) {
-            this.node = node;
-            this.parent = parent;
-            this.depth = depth;
-        }
+    if (root.val == x) {
+      p.depth = currDepth;
+      p.parent = parent;
     }
+    else {
+      helper(root.left, x, currDepth + 1, root, p);
+      helper(root.right, x, currDepth + 1, root, p);
+    }
+  }
+}
+
+class ParentData {
+  int depth;
+  TreeNode parent;
+  
+  public ParentData() {
+    this.depth = 0;
+    this.parent = null;
+  }
 }

From 872e1b1b7e6f5b94e4684e874dddd05042eb7813 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 14 Feb 2020 07:04:11 -0800
Subject: [PATCH 0103/2175] Added 1 solution & modified 3 solutions

---
 Easy/Convert BST to greater tree.java        | 27 ++++++------
 Easy/Merge two binary trees.java             | 27 ++++++------
 Easy/Sum of Root To Leaf Binary Numbers.java | 45 ++++++++++++++++++++
 Easy/Univalued Binary Tree.java              | 32 ++++++--------
 4 files changed, 88 insertions(+), 43 deletions(-)
 create mode 100644 Easy/Sum of Root To Leaf Binary Numbers.java

diff --git a/Easy/Convert BST to greater tree.java b/Easy/Convert BST to greater tree.java
index 390d5b93..f4b736f3 100644
--- a/Easy/Convert BST to greater tree.java	
+++ b/Easy/Convert BST to greater tree.java	
@@ -8,18 +8,19 @@
  * }
  */
 class Solution {
-    
-    int sum = 0;
-    public TreeNode convertBST(TreeNode root) {
-        convert(root);
-        return root;
-    }
-    
-    public void convert(TreeNode cur) {
-        if (cur == null) return;
-        convert(cur.right);
-        cur.val += sum;
-        sum = cur.val;
-        convert(cur.left);
+  int updatedVal = 0;
+  public TreeNode convertBST(TreeNode root) {
+    helper(root);
+    return root;
+  }
+  
+  private void helper(TreeNode root) {
+    if (root == null) {
+      return;
     }
+    helper(root.right);
+    updatedVal += root.val;
+    root.val = updatedVal;
+    helper(root.left);
+  }
 }
diff --git a/Easy/Merge two binary trees.java b/Easy/Merge two binary trees.java
index c3ba2dfa..d91c7643 100644
--- a/Easy/Merge two binary trees.java	
+++ b/Easy/Merge two binary trees.java	
@@ -8,17 +8,20 @@
  * }
  */
 class Solution {
-    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
-        if (t1 == null && t2 == null) {
-            return null;
-        }
-        
-        int v = (t1 == null ? 0 : t1.val) + (t2 == null ? 0 : t2.val);
-        TreeNode newNode = new TreeNode(v);
-        
-        newNode.left = mergeTrees(t1==null ? null : t1.left, t2==null ? null : t2.left);
-        newNode.right = mergeTrees(t1==null ? null : t1.right, t2==null ? null : t2.right);
-        
-        return newNode;
+  public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+    if (t1 == null && t2 == null) {
+      return null;
     }
+    int val = (t1 == null ? 0 : t1.val) + (t2 == null ? 0 : t2.val); 
+    TreeNode root = new TreeNode(val);
+    root.left = mergeTrees(
+      t1 == null ? null : t1.left, 
+      t2 == null ? null : t2.left
+    );
+    root.right = mergeTrees(
+      t1 == null ? null : t1.right, 
+      t2 == null ? null : t2.right
+    );
+    return root;
+  }
 }
diff --git a/Easy/Sum of Root To Leaf Binary Numbers.java b/Easy/Sum of Root To Leaf Binary Numbers.java
new file mode 100644
index 00000000..38f871ec
--- /dev/null
+++ b/Easy/Sum of Root To Leaf Binary Numbers.java	
@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  List<String> list;
+  public int sumRootToLeaf(TreeNode root) {
+    list = new ArrayList<>();
+    helper(root, new StringBuilder());
+    int ans = 0;
+    for (String num : list) {
+      ans += getIntegerVal(num);
+    }
+    return ans;
+  }
+  
+  private void helper(TreeNode root, StringBuilder sb) {
+    if (root == null) {
+      return;
+    }
+    sb.append(root.val);
+    if (root.left == null && root.right == null) {
+      list.add(sb.toString());
+    }
+    else {
+      helper(root.left, new StringBuilder(sb.toString()));
+      helper(root.right, new StringBuilder(sb.toString()));
+    }
+  }
+  
+  private int getIntegerVal(String s) {
+    int num = 0;
+    int pow = 1;
+    for (int i = s.length() - 1; i >= 0; i--) {
+      num += Character.getNumericValue(s.charAt(i)) * pow;
+      pow *= 2;
+    }
+    return num;
+  }
+}
diff --git a/Easy/Univalued Binary Tree.java b/Easy/Univalued Binary Tree.java
index 2ac4196d..cba6d177 100644
--- a/Easy/Univalued Binary Tree.java	
+++ b/Easy/Univalued Binary Tree.java	
@@ -8,24 +8,20 @@
  * }
  */
 class Solution {
-    int currVal;
-    public boolean isUnivalTree(TreeNode root) {
-        currVal = Integer.MAX_VALUE;
-        return isUnivalTreeHelper(root);
+  public boolean isUnivalTree(TreeNode root) {
+    if (root == null) {
+      return true;
     }
-    
-    private boolean isUnivalTreeHelper(TreeNode root) {
-        if (root == null) {
-            return true;
-        }
-        
-        if (currVal == Integer.MAX_VALUE) {
-            currVal = root.val;
-        }
-        else if (currVal != root.val) {
-            return false;
-        }
-        
-        return isUnivalTreeHelper(root.left) && isUnivalTreeHelper(root.right);
+    return helper(root, root.val);
+  }
+  
+  private boolean helper(TreeNode root, int val) {
+    if (root == null) {
+      return true;
     }
+    if (root.val != val) {
+      return false;
+    }
+    return helper(root.left, val) && helper(root.right, val);
+  }
 }

From 1032199b8a49b6d8626b900abb3918ba7f9bc124 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 18 Feb 2020 04:44:54 -0800
Subject: [PATCH 0104/2175] Added 2 solutions & modified 1 solution

---
 ...t Negative Numbers in a Sorted Matrix.java | 28 ++++++++
 Medium/Maximum Average Subtree.java           | 69 +++++--------------
 Medium/Product of the Last K Numbers.java     | 27 ++++++++
 3 files changed, 74 insertions(+), 50 deletions(-)
 create mode 100644 Easy/Count Negative Numbers in a Sorted Matrix.java
 create mode 100644 Medium/Product of the Last K Numbers.java

diff --git a/Easy/Count Negative Numbers in a Sorted Matrix.java b/Easy/Count Negative Numbers in a Sorted Matrix.java
new file mode 100644
index 00000000..96daf80b
--- /dev/null
+++ b/Easy/Count Negative Numbers in a Sorted Matrix.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public int countNegatives(int[][] grid) {
+    int total = 0;
+    int n = grid[0].length;
+    for (int[] gr : grid) {
+      int negInd = binarySearchHelper(gr, 0, n - 1);
+      if (negInd != -1) {
+        total += n - negInd;
+      }
+    }
+    return total;
+  }
+  
+  private int binarySearchHelper(int[] arr, int start, int end) {
+    int idx = -1;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (arr[mid] < 0) {
+        idx = idx == -1 ? mid : Math.min(idx, mid);
+        end = mid - 1;
+      }
+      if (arr[mid] >= 0) {
+        start = mid + 1;
+      }
+    }
+    return idx;
+  }
+}
diff --git a/Medium/Maximum Average Subtree.java b/Medium/Maximum Average Subtree.java
index c422844b..97c54cf6 100644
--- a/Medium/Maximum Average Subtree.java	
+++ b/Medium/Maximum Average Subtree.java	
@@ -8,55 +8,24 @@
  * }
  */
 class Solution {
-    Map<TreeNode, Integer> sumMap = new HashMap<>();
-    Map<TreeNode, Integer> numNodesMap = new HashMap<>();
-    double maxAvg = -1.0;
-    public double maximumAverageSubtree(TreeNode root) {
-        dfs(root);
-        return maxAvg;
-    }
-    
-    private void dfs(TreeNode root) {
-        if (root == null) {
-            return;
-        }
-        
-        int sum = getSum(root);
-        int nodes = getNumOfNodes(root);
-        
-        maxAvg = Math.max(maxAvg, ((double) (sum) / nodes));
-        
-        dfs(root.left);
-        dfs(root.right);
-    }
-    
-    private int getSum(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        
-        if (sumMap.containsKey(root)) {
-            return sumMap.get(root);
-        }
-        
-        int sum = root.val + getSum(root.left) + getSum(root.right);
-        sumMap.put(root, sum);
-        
-        return sum;
-    }
-    
-    private int getNumOfNodes(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        
-        if (numNodesMap.containsKey(root)) {
-            return numNodesMap.get(root);
-        }
-        
-        int numNodes = 1 + getNumOfNodes(root.left) + getNumOfNodes(root.right);
-        numNodesMap.put(root, numNodes);
-        
-        return numNodes;
+  double maxAvg;
+  public double maximumAverageSubtree(TreeNode root) {
+    maxAvg = 0.0;
+    helper(root);
+    return maxAvg;
+  }
+  
+  private int[] helper(TreeNode root) {
+    int[] data = new int[2];
+    if (root == null) {
+      return data;
     }
+    int[] dataLeft = helper(root.left);
+    int[] dataRight = helper(root.right);
+    data[0] += root.val + dataLeft[0] + dataRight[0];
+    data[1] += 1 + dataLeft[1] + dataRight[1];
+    double avg = ((double) data[0]) / data[1];
+    maxAvg = Math.max(maxAvg, avg);
+    return data;
+  }
 }
diff --git a/Medium/Product of the Last K Numbers.java b/Medium/Product of the Last K Numbers.java
new file mode 100644
index 00000000..9eda5d06
--- /dev/null
+++ b/Medium/Product of the Last K Numbers.java	
@@ -0,0 +1,27 @@
+class ProductOfNumbers {
+  List<Integer> list;
+  public ProductOfNumbers() {
+    add(0);
+  }
+
+  public void add(int num) {
+    if (num > 0) {
+      list.add(list.get(list.size() - 1) * num);
+    }
+    else {
+      list = new ArrayList<>();
+      list.add(1);
+    }
+  }
+
+  public int getProduct(int k) {
+    return k < list.size() ? list.get(list.size() - 1) / list.get(list.size() - k - 1) : 0;
+  }
+}
+
+/**
+ * Your ProductOfNumbers object will be instantiated and called as such:
+ * ProductOfNumbers obj = new ProductOfNumbers();
+ * obj.add(num);
+ * int param_2 = obj.getProduct(k);
+ */

From edf31b0613f65259a179dfef4b6ea3acb84d1d6c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 18 Feb 2020 05:55:58 -0800
Subject: [PATCH 0105/2175] Added 1 solution & modified 2 solutions

---
 Easy/Intersection of Three Sorted Arrays.java | 21 +++++++++
 Easy/N-Repeated Element in Size 2N Array.java | 22 +++++----
 Easy/Subdomain Visit Count.java               | 45 ++++++++-----------
 3 files changed, 49 insertions(+), 39 deletions(-)
 create mode 100644 Easy/Intersection of Three Sorted Arrays.java

diff --git a/Easy/Intersection of Three Sorted Arrays.java b/Easy/Intersection of Three Sorted Arrays.java
new file mode 100644
index 00000000..71e66b1c
--- /dev/null
+++ b/Easy/Intersection of Three Sorted Arrays.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public List<Integer> arraysIntersection(int[] arr1, int[] arr2, int[] arr3) {
+    int[] counter = new int[2001];
+    updateCounter(counter, arr1);
+    updateCounter(counter, arr2);
+    updateCounter(counter, arr3);
+    List<Integer> ans = new ArrayList<>();
+    for (int i = 0; i < 2001; i++) {
+      if (counter[i] == 3) {
+        ans.add(i);
+      }
+    }
+    return ans;
+  }
+  
+  private void updateCounter(int[] counter, int[] arr) {
+    for (int num : arr) {
+      counter[num]++;
+    }
+  }
+}
diff --git a/Easy/N-Repeated Element in Size 2N Array.java b/Easy/N-Repeated Element in Size 2N Array.java
index 5ef779c5..890bf336 100644
--- a/Easy/N-Repeated Element in Size 2N Array.java	
+++ b/Easy/N-Repeated Element in Size 2N Array.java	
@@ -1,15 +1,13 @@
 class Solution {
-    public int repeatedNTimes(int[] A) {
-        int maxCounter = A.length / 2;
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int num : A) {
-            map.put(num, map.getOrDefault(num, 0) + 1);
-            
-            if (map.get(num) == maxCounter) {
-                return num;
-            }
-        }
-        
-        return -1;
+  public int repeatedNTimes(int[] A) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int n = A.length / 2;
+    for (int num : A) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+      if (map.get(num) == n) {
+        return num;
+      }
     }
+    return -1;
+  }
 }
diff --git a/Easy/Subdomain Visit Count.java b/Easy/Subdomain Visit Count.java
index f3e711ba..c6eb65a0 100644
--- a/Easy/Subdomain Visit Count.java	
+++ b/Easy/Subdomain Visit Count.java	
@@ -1,31 +1,22 @@
 class Solution {
-    public List<String> subdomainVisits(String[] cpdomains) {
-        Map<String, Integer> map = new HashMap<>();
-        
-        for (String s : cpdomains) {
-            String[] strs = s.split("\\s+");
-            int count = Integer.parseInt(strs[0]);
-            String[] domains = strs[1].split("\\.");
-            
-            String temp = domains[domains.length-1];
-            int domainLen = domains.length-1;
-            
-            while(domainLen >= 0) {
-                map.put(temp, map.getOrDefault(temp, 0) + count);
-                if (domainLen > 0) {
-                	temp = domains[domainLen-1] + "." + temp;
-                }
-                domainLen--;
-            }
-            
+  public List<String> subdomainVisits(String[] cpdomains) {
+    Map<String, Integer> map = new HashMap<>();
+    for(String domain : cpdomains) {
+      int count = Integer.parseInt(domain.split("\\s+")[0]);
+      String[] subDomains = domain.split("\\s+")[1].split("\\.");
+      StringBuilder sb = new StringBuilder();
+      for (int i = subDomains.length - 1; i >= 0; i--) {
+        if (sb.length() != 0) {
+          sb.insert(0, ".");
         }
-        
-        List<String> ans = new ArrayList<>();
-        for (Map.Entry<String, Integer> entry : map.entrySet()) {
-            String str = String.valueOf(entry.getValue()) + " " + entry.getKey();
-            ans.add(str);
-        }
-        
-        return ans;
+        sb.insert(0, subDomains[i]);
+        map.put(sb.toString(), map.getOrDefault(sb.toString(), 0) + count);
+      }
+    }
+    List<String> list = new ArrayList<>();
+    for (String key : map.keySet()) {
+      list.add(map.get(key) + " " + key);
     }
+    return list;
+  }
 }

From 65505a766f2430d40e9c9c40efde523d225ccc4e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 19 Feb 2020 07:11:45 -0800
Subject: [PATCH 0106/2175] Modified 2 solutions

---
 Medium/Simplify Path.java    | 69 ++++++++++++-----------------
 Medium/Spiral Matrix II.java | 86 +++++++++++-------------------------
 2 files changed, 55 insertions(+), 100 deletions(-)

diff --git a/Medium/Simplify Path.java b/Medium/Simplify Path.java
index a968b625..b272d133 100644
--- a/Medium/Simplify Path.java	
+++ b/Medium/Simplify Path.java	
@@ -1,46 +1,35 @@
 class Solution {
-    public String simplifyPath(String path) {
-        Stack<String> stack = new Stack<>();
-        StringBuilder sb = new StringBuilder();
-        int idx = 0;
-        int n = path.length();
-
-        while (idx < n) {
-            if (path.charAt(idx) != '/') {
-                sb.append(path.charAt(idx));
-                while (idx + 1 < n && path.charAt(idx + 1) != '/') {
-                    sb.append(path.charAt(idx + 1));
-                    idx++;
-                }
-
-                if (sb.toString().equals("..")) {
-                    if (!stack.isEmpty()) {
-                        stack.pop();
-                    }
-                }
-                else if (!sb.toString().equals(".")) {
-                    stack.push(sb.toString());
-                }
-
-                sb.setLength(0);
-            }
-
-            idx++;
+  public String simplifyPath(String path) {
+    Stack<String> stack = new Stack<>();
+    StringBuilder sb = new StringBuilder();
+    int idx = 0;
+    int n = path.length();
+    while (idx < n) {
+      if (path.charAt(idx) == '/') {
+        idx++;
+        while (idx < n && path.charAt(idx) != '/') {
+          sb.append(path.charAt(idx++));
         }
-
-        List<String> list = new ArrayList<>();
-        while (!stack.isEmpty()) {
-            list.add(stack.pop());
+        String dir = sb.toString();
+        sb.setLength(0);
+        if (dir.equals("..")) {
+          if (!stack.isEmpty()) {
+            stack.pop(); 
+          }
         }
-
-        sb.append("/");
-        for (int i = list.size() - 1; i >= 0; i--) {
-            sb.append(list.get(i));
-            if (i != 0) {
-                sb.append("/");
-            }
+        else if (dir.equals(".") || dir.length() == 0) {
+          continue;
         }
-
-        return sb.toString();
+        else {
+          stack.push(dir);
+        }
+      }
+    }
+    sb = new StringBuilder();
+    while (!stack.isEmpty()) {
+      sb.insert(0, stack.pop());
+      sb.insert(0, "/");
     }
+    return sb.length() > 0 ? sb.toString() : "/";
+  }
 }
diff --git a/Medium/Spiral Matrix II.java b/Medium/Spiral Matrix II.java
index 70e30421..ffa09b62 100644
--- a/Medium/Spiral Matrix II.java	
+++ b/Medium/Spiral Matrix II.java	
@@ -1,63 +1,29 @@
 class Solution {
-    public int[][] generateMatrix(int n) {
-        if (n == 0) {
-            return new int[0][0];
-        }
-
-        int[][] matrix = new int[n][n];
-        int i = 0;
-        int j = 0;
-        int top = 0;
-        int bottom = n;
-        int left = 0;
-        int right = n;
-        int dir = 0;
-        int count = 1;
-        int limit = n*n;
-
-        while (count <= limit) {
-            if (dir == 0) {
-                while (j < right) {
-                    matrix[i][j++] = count;
-                    count++;
-                }
-                dir++;
-                right--;
-                i++;
-                j--;
-            }
-            else if (dir == 1) {
-                while (i < bottom) {
-                    matrix[i++][j] = count;
-                    count++;
-                }
-                dir++;
-                bottom--;
-                i--;
-                j--;
-            }
-            else if (dir == 2) {
-                while (j >= left) {
-                    matrix[i][j--] = count;
-                    count++;
-                }
-                dir++;
-                i--;
-                j++;
-                left++;
-            }
-            else if (dir == 3) {
-                while (i > top) {
-                    matrix[i--][j] = count;
-                    count++;
-                }
-                dir = 0;
-                top++;
-                i++;
-                j++;
-            }
-        }
-
-        return matrix;
+  public int[][] generateMatrix(int n) {
+    int[][] ans = new int[n][n];
+    int left = 0;
+    int top = 0;
+    int right = n -1;
+    int down = n - 1;
+    int count = 1;
+    while (left <= right) {
+      for (int j = left; j <= right; j ++) {
+        ans[top][j] = count++;
+      }
+      top++;
+      for (int i = top; i <= down; i ++) {
+        ans[i][right] = count ++;
+      }
+      right--;
+      for (int j = right; j >= left; j --) {
+        ans[down][j] = count ++;
+      }
+      down--;
+      for (int i = down; i >= top; i --) {
+        ans[i][left] = count ++;
+      }
+      left++;
     }
+    return ans;
+  }
 }

From 69f20382ff256ef7b8390523c5c4c5af68dedad2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 21 Feb 2020 07:33:03 -0800
Subject: [PATCH 0107/2175] Modified 4 solutions

---
 Easy/Keyboard Row.java                | 65 ++++++++++++---------------
 Easy/Largest Unique Number.java       | 26 +++++------
 Easy/Reverse String II.java           | 38 +++++++++-------
 Medium/Prison Cells After N Days.java | 29 ++++++------
 4 files changed, 76 insertions(+), 82 deletions(-)

diff --git a/Easy/Keyboard Row.java b/Easy/Keyboard Row.java
index 80b4aaa1..e83946aa 100644
--- a/Easy/Keyboard Row.java	
+++ b/Easy/Keyboard Row.java	
@@ -1,42 +1,35 @@
 class Solution {
-    public String[] findWords(String[] words) {
-        ArrayList<String> ans = new ArrayList<String>();
-        
-        for (int i=0;i<words.length;i++) {
-            if (canBeTyped(words[i])) {
-                ans.add(words[i]);
-            }
+  public String[] findWords(String[] words) {
+    Map<Character, Integer> map = new HashMap<>();
+    update(map, "qwertyuiop", 1);
+    update(map, "asdfghjkl", 2);
+    update(map, "zxcvbnm", 3);
+    List<Integer> list = new ArrayList<>();
+    for (int i = 0; i < words.length; i++) {
+      int rowIdx = -1;
+      for (char c : words[i].toCharArray()) {
+        if (rowIdx == -1) {
+          rowIdx = map.get(Character.toLowerCase(c));
         }
-        
-        String[] ansArr = new String[ans.size()];
-        for (int i=0;i<ansArr.length;i++) {
-            ansArr[i] = ans.get(i);
+        if (map.get(Character.toLowerCase(c)) != rowIdx) {
+          rowIdx = -1;
+          break;
         }
-        
-        return ansArr;
+      }
+      if (rowIdx != -1) {
+        list.add(i);
+      }
     }
-    
-    public boolean canBeTyped(String s) {
-        s = s.toLowerCase();
-        String[] keys = {"qwertyuiop", "asdfghjkl", "zxcvbnm"};
-        
-        int keyId = 0;
-        if (keys[0].indexOf(s.charAt(0)) != -1) {
-            keyId = 0;
-        }
-        else if (keys[1].indexOf(s.charAt(0)) != -1) {
-            keyId = 1;
-        }
-        else if (keys[2].indexOf(s.charAt(0)) != -1) {
-            keyId = 2;
-        }
-        
-        for (int i=1;i<s.length();i++) {
-            if (keys[keyId].indexOf(s.charAt(i)) == -1) {
-                return false;
-            }
-        }
-        
-        return true;
+    String[] ans = new String[list.size()];
+    for (int i = 0; i < list.size(); i++) {
+      ans[i] = words[list.get(i)];
+    }
+    return ans;
+  }
+  
+  private void update(Map<Character, Integer> map, String s, int row) {
+    for (char c : s.toCharArray()) {
+      map.put(c, row);
     }
+  }
 }
diff --git a/Easy/Largest Unique Number.java b/Easy/Largest Unique Number.java
index 00191b7b..0c6df9b9 100644
--- a/Easy/Largest Unique Number.java	
+++ b/Easy/Largest Unique Number.java	
@@ -1,17 +1,15 @@
 class Solution {
-    public int largestUniqueNumber(int[] A) {
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int num : A) {
-            map.put(num, map.getOrDefault(num, 0) + 1);
-        }
-
-        int maxVal = Integer.MIN_VALUE;
-        for (Integer key : map.keySet()) {
-            if (map.get(key) == 1) {
-                maxVal = Math.max(maxVal, key);
-            }
-        }
-
-        return maxVal == Integer.MIN_VALUE ? -1 : maxVal;
+  public int largestUniqueNumber(int[] A) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : A) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
     }
+    int max = -1;
+    for (Integer key : map.keySet()) {
+      if (map.get(key) == 1) {
+        max = Math.max(key, max);
+      }
+    }
+    return max;
+  }
 }
diff --git a/Easy/Reverse String II.java b/Easy/Reverse String II.java
index 6534c687..a2e13d9a 100644
--- a/Easy/Reverse String II.java	
+++ b/Easy/Reverse String II.java	
@@ -1,21 +1,27 @@
 class Solution {
-    public String reverseStr(String s, int k) {
-        char[] arr = s.toCharArray();
-        int n = arr.length;
-        int i = 0;
-        while(i < n) {
-            int j = Math.min(i + k - 1, n - 1);
-            swap(arr, i, j);
-            i += 2 * k;
+  public String reverseStr(String s, int k) {
+    StringBuilder sb = new StringBuilder();
+    boolean current = true;
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      int endIdx = Math.min(idx + k - 1, n - 1);
+      if (current) {
+        int end = idx;
+        int start = endIdx;
+        for (int i = start; i >= end; i--) {
+          sb.append(s.charAt(i));
         }
-        return String.valueOf(arr);
-    }
-    
-    private void swap(char[] arr, int l, int r) {
-        while (l < r) {
-            char temp = arr[l];
-            arr[l++] = arr[r];
-            arr[r--] = temp;
+        idx = endIdx + 1;
+      }
+      else {
+        while (idx <= endIdx) {
+          sb.append(s.charAt(idx++));
         }
+      }
+      current = !current;
+      System.out.println(idx);
     }
+    return sb.toString();
+  }
 }
diff --git a/Medium/Prison Cells After N Days.java b/Medium/Prison Cells After N Days.java
index a793b51c..ca9a58f7 100644
--- a/Medium/Prison Cells After N Days.java	
+++ b/Medium/Prison Cells After N Days.java	
@@ -1,20 +1,17 @@
 class Solution {
-    public int[] prisonAfterNDays(int[] cells, int N) {
-        Map<String, Integer> map = new HashMap<>();
-        while (N > 0) {
-            int[] temp = new int[8];
-            map.put(Arrays.toString(cells), N--);
-            for (int i = 1; i < 7; i++) {
-                temp[i] = cells[i - 1] == cells[i + 1] ? 1 : 0;
-            }
-            
-            cells = temp;
-            
-            if (map.containsKey(Arrays.toString(cells))) {
-                N %= map.get(Arrays.toString(cells)) - N;
-            }
+  public int[] prisonAfterNDays(int[] cells, int N) {
+    Map<String, Integer> seen = new HashMap<>();
+    while (N > 0) {
+        int[] cells2 = new int[8];
+        seen.put(Arrays.toString(cells), N--);
+        for (int i = 1; i < 7; ++i) {
+            cells2[i] = cells[i - 1] == cells[i + 1] ? 1 : 0;
+        }
+        cells = cells2;
+        if (seen.containsKey(Arrays.toString(cells))) {
+            N %= seen.get(Arrays.toString(cells)) - N;
         }
-        
-        return cells;
     }
+    return cells;
+  }
 }

From cadc923106964f58d9d7a7892c23e5ec1d8ff96c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 22 Feb 2020 15:48:19 -0800
Subject: [PATCH 0108/2175] Added 2 solutions & modified 2 solutions

---
 ...Sort Integers by The Number of 1 Bits.java | 22 ++++++++
 Medium/Apply Discount Every n Orders.java     | 37 +++++++++++++
 Medium/Remove K Digits.java                   | 54 ++++++++-----------
 Medium/Sort Colors.java                       | 42 ++++++++-------
 4 files changed, 103 insertions(+), 52 deletions(-)
 create mode 100644 Easy/Sort Integers by The Number of 1 Bits.java
 create mode 100644 Medium/Apply Discount Every n Orders.java

diff --git a/Easy/Sort Integers by The Number of 1 Bits.java b/Easy/Sort Integers by The Number of 1 Bits.java
new file mode 100644
index 00000000..47e3fb6e
--- /dev/null
+++ b/Easy/Sort Integers by The Number of 1 Bits.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int[] sortByBits(int[] arr) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
+      public int compare(Integer o1, Integer o2) {
+        int c = Integer.bitCount(o1) - Integer.bitCount(o2);
+        if (c != 0) {
+          return c;
+        }
+        return o1 - o2;
+      }
+    });
+    for (int num : arr) {
+      pq.add(num);
+    }
+    int[] ans = new int[arr.length];
+    int idx = 0;
+    while (!pq.isEmpty()) {
+      ans[idx++] = pq.poll();
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Apply Discount Every n Orders.java b/Medium/Apply Discount Every n Orders.java
new file mode 100644
index 00000000..18fcf078
--- /dev/null
+++ b/Medium/Apply Discount Every n Orders.java	
@@ -0,0 +1,37 @@
+class Cashier {
+  int n;
+  int discount;
+  int currCount;
+  Map<Integer, Integer> priceMap;
+  public Cashier(int n, int discount, int[] products, int[] prices) {
+    this.n = n;
+    this.currCount = 0;
+    this.discount = discount;
+    priceMap = new HashMap<>();
+    for (int i = 0; i < products.length; i++) {
+      priceMap.put(products[i], prices[i]);
+    }
+  }
+
+  public double getBill(int[] product, int[] amount) {
+    currCount++;
+    double totalBill = 0;
+    for (int i = 0; i < product.length; i++) {
+      totalBill += amount[i] * priceMap.get(product[i]);
+    }
+    if (currCount % n == 0) {
+      totalBill -= getDiscount(totalBill);
+    }
+    return totalBill;
+  }
+  
+  private double getDiscount(double totalBill) {
+    return (totalBill * discount) / 100;
+  }
+}
+
+/**
+ * Your Cashier object will be instantiated and called as such:
+ * Cashier obj = new Cashier(n, discount, products, prices);
+ * double param_1 = obj.getBill(product,amount);
+ */
diff --git a/Medium/Remove K Digits.java b/Medium/Remove K Digits.java
index 6166b173..f42a2575 100644
--- a/Medium/Remove K Digits.java	
+++ b/Medium/Remove K Digits.java	
@@ -1,35 +1,25 @@
 class Solution {
-    public String removeKdigits(String num, int k) {
-        Stack<Integer> stack = new Stack<>();
-        int idx = 0;
-        int n = num.length();
-        while (idx < n) {
-            while (k > 0 && !stack.isEmpty()) {
-                if (stack.peek() <= Character.getNumericValue(num.charAt(idx))) {
-                    break;
-                }
-                stack.pop();
-                k--;
-            }
-            
-            stack.push(Character.getNumericValue(num.charAt(idx++)));
-        }
-        
-        while (k-- > 0) {
-            stack.pop();
-        }
-        
-        StringBuilder sb = new StringBuilder();
-        while (!stack.isEmpty()) {
-            sb.append(stack.pop());
-        }
-        
-        String ans = sb.reverse().toString();
-        idx = -1;
-        while (idx + 1 < ans.length() && ans.charAt(idx + 1) == '0') {
-            idx++;
-        }
-        
-        return ans.substring(idx + 1).length() == 0 ? "0" : ans.substring(idx + 1);
+  public String removeKdigits(String num, int k) {
+    LinkedList<Character> stack = new LinkedList<>();
+    for (char c : num.toCharArray()) {
+      while (!stack.isEmpty() && k > 0 && stack.peekLast() > c) {
+        stack.removeLast();
+        k--;
+      } 
+      stack.addLast(c);
     }
+    while (k-- > 0) {
+      stack.removeLast();
+    }
+    StringBuilder sb = new StringBuilder();
+    boolean currZero = true;
+    for (char c : stack) {
+      if (currZero && c == '0') {
+        continue;
+      }
+      currZero = false;
+      sb.append(c);
+    }
+    return sb.length() == 0 ? "0" : sb.toString();
+  }
 }
diff --git a/Medium/Sort Colors.java b/Medium/Sort Colors.java
index fee68c3b..6fc66d88 100644
--- a/Medium/Sort Colors.java	
+++ b/Medium/Sort Colors.java	
@@ -1,23 +1,25 @@
 class Solution {
-    public void sortColors(int[] nums) {
-        int idx1 = 0;
-        int idx2 = nums.length - 1;
-        int idx = 0;
-        
-        while (idx <= idx2) {
-            if (nums[idx] == 0) {
-                nums[idx] = nums[idx1];
-                nums[idx1] = 0;
-                idx1++;
-            }
-            if (nums[idx] == 2) {
-                nums[idx] = nums[idx2];
-                nums[idx2] = 2;
-                idx2--;
-                idx--;
-            }
-            
-            idx++;
-        }
+  public void sortColors(int[] nums) {
+    int zeroIdx = 0;
+    int curr = 0;
+    int n = nums.length - 1;
+    int twoIdx = n;
+    while (curr <= twoIdx) {
+      if (nums[curr] == 0) {
+        swap(nums, curr++, zeroIdx++);
+      }
+      else if (nums[curr] == 2) {
+        swap(nums, curr, twoIdx--);
+      }
+      else {
+        curr++;
+      }
     }
+  }
+  
+  private void swap(int[] nums, int idx1, int idx2) {
+    int temp = nums[idx1];
+    nums[idx1] = nums[idx2];
+    nums[idx2] = temp;
+  }
 }

From f780f376a87951e6aa1d44cb3b50d41cd7913a57 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 23 Feb 2020 09:53:17 -0800
Subject: [PATCH 0109/2175] Added 1 solution & modified 9 solutions

---
 ...rt Sorted Array To Binary Search Tree.java |  36 +++---
 Easy/Implement strStr.java                    |  24 ++--
 Easy/Maximize Distance to Closest Person.java |  45 +++----
 Easy/Merge Sorted Arrays.java                 |  30 +++--
 Easy/Rotated Digits.java                      |  66 +++++-----
 Medium/Boundary of Binary Tree.java           |  53 ++++----
 Medium/Distribute Coins in Binary Tree.java   |  40 +++---
 Medium/Implement Trie (Prefix Tree).java      | 116 +++++++++---------
 Medium/Inorder Successor in BST.java          |  47 +++----
 Medium/Knight Dialer.java                     |  41 +++++++
 10 files changed, 257 insertions(+), 241 deletions(-)
 create mode 100644 Medium/Knight Dialer.java

diff --git a/Easy/Convert Sorted Array To Binary Search Tree.java b/Easy/Convert Sorted Array To Binary Search Tree.java
index e595edc3..55cbd37e 100644
--- a/Easy/Convert Sorted Array To Binary Search Tree.java	
+++ b/Easy/Convert Sorted Array To Binary Search Tree.java	
@@ -8,26 +8,20 @@
  * }
  */
 class Solution {
-    public TreeNode sortedArrayToBST(int[] nums) {
-        if (nums.length == 0) {
-            return null;
-        }
-        
-        TreeNode root = convertToBST(nums, 0, nums.length-1);
-        return root;
-    }
-    
-    public TreeNode convertToBST(int[] nums, int low, int high) {
-        if (low > high) {
-            return null;
-        }
-        
-        int mid = (low + high)/2;
-        TreeNode root = new TreeNode(nums[mid]);
-        
-        root.left = convertToBST(nums,low,mid-1);
-        root.right = convertToBST(nums,mid+1,high);
-        
-        return root;
+  public TreeNode sortedArrayToBST(int[] nums) {
+    int left = 0;
+    int right = nums.length - 1;
+    return helper(nums, left, right);
+  }
+  
+  private TreeNode helper(int[] nums, int left, int right) {
+    if (left > right) {
+      return null;
     }
+    int mid = (left + right) / 2;
+    TreeNode root = new TreeNode(nums[mid]);
+    root.left = helper(nums, left, mid - 1);
+    root.right = helper(nums, mid + 1, right);
+    return root;
+  }
 }
diff --git a/Easy/Implement strStr.java b/Easy/Implement strStr.java
index a823b793..bf12a2ed 100644
--- a/Easy/Implement strStr.java	
+++ b/Easy/Implement strStr.java	
@@ -1,16 +1,14 @@
 class Solution {
-    public int strStr(String haystack, String needle) {
-        int start = 0;
-        int end = haystack.length() - needle.length() + 1;
-        
-        while (start < end) {
-            if (haystack.substring(start, start + needle.length()).equals(needle)) {
-                return start;
-            }
-            
-            start++;
-        }
-        
-        return -1;
+  public int strStr(String haystack, String needle) {
+    int hayLength = haystack.length();
+    int needleLength = needle.length();
+    int idx = 0;
+    while (idx + needleLength <= hayLength) {
+      if (haystack.substring(idx, idx + needleLength).equals(needle)) {
+        return idx;
+      }
+      idx++;
     }
+    return -1;
+  }
 }
diff --git a/Easy/Maximize Distance to Closest Person.java b/Easy/Maximize Distance to Closest Person.java
index c9ba8bfe..a5d4d304 100644
--- a/Easy/Maximize Distance to Closest Person.java	
+++ b/Easy/Maximize Distance to Closest Person.java	
@@ -1,28 +1,23 @@
 class Solution {
-    public static int maxDistToClosest(int[] seats) {
-        int left = -1;
-        int max = 0;
-        int length = seats.length;
-
-        for (int i=0; i<length; i++) {
-            if (seats[i] == 0) {
-                continue;
-            }
-
-            if (left == -1) {
-                max = Math.max(max, i);
-            }
-            else {
-                max = Math.max(max, (i-left)/2);
-            }
-
-            left = i;
-        }
-
-        if (seats[length - 1] == 0) {
-            max = Math.max(max, length - 1 - left);
-        }
-        
-        return max;
+  public int maxDistToClosest(int[] seats) {
+    int start = -1;
+    int max = 0;
+    int n = seats.length;
+    for (int i = 0; i < n; i++) {
+      if (seats[i] == 0) {
+        continue;
+      }
+      if (start == -1) {
+        max = Math.max(max, i);
+      }
+      else {
+        max = Math.max(max, (i - start) / 2);
+      }
+      start = i;
     }
+    if (seats[n - 1] == 0) {
+      max = Math.max(max, n - 1 - start);
+    }
+    return max;
+  }
 }
diff --git a/Easy/Merge Sorted Arrays.java b/Easy/Merge Sorted Arrays.java
index 816d814c..d734d76a 100644
--- a/Easy/Merge Sorted Arrays.java	
+++ b/Easy/Merge Sorted Arrays.java	
@@ -1,15 +1,25 @@
 class Solution {
-    public void merge(int[] nums1, int m, int[] nums2, int n) {
-        int i = m-1;
-        int j = n-1;
-        int k = m+n-1;
-        
-        while (i>-1 && j>-1) {
-            nums1[k--] = nums1[i] > nums2[j] ? nums1[i--] : nums2[j--];
+  public void merge(int[] nums1, int m, int[] nums2, int n) {
+    int counter = m + n - 1;
+    int num1End = m - 1;
+    int num2End = n - 1;
+    while (num1End >= 0 || num2End >= 0) {
+      int val = -1;
+      if (num1End >= 0 && num2End >= 0) {
+        if (nums1[num1End] > nums2[num2End]) {
+          val = nums1[num1End--];
         }
-        
-        while (j>-1) {
-            nums1[k--] = nums2[j--];
+        else {
+          val = nums2[num2End--];
         }
+      }
+      else if (num1End >= 0 || num2End < 0) {
+        val = nums1[num1End--];
+      }
+      else {
+        val = nums2[num2End--];
+      }
+      nums1[counter--] = val;
     }
+  }
 }
diff --git a/Easy/Rotated Digits.java b/Easy/Rotated Digits.java
index 51f19871..2bc9a2dc 100644
--- a/Easy/Rotated Digits.java	
+++ b/Easy/Rotated Digits.java	
@@ -1,40 +1,30 @@
 class Solution {
-    public int rotatedDigits(int N) {
-        int count = 0;
-        for (int i=1;i<=N;i++) {
-            if (isValid(i)) {
-            	count++;
-            }
-        }
-        return count;
+  public int rotatedDigits(int N) {
+    int count = 0;
+    for (int i = 1; i <= N; i++) {
+      if (isGood(String.valueOf(i))) {
+        count++;
+      }
     }
-
-    public boolean isValid(int n) {
-    	String s = String.valueOf(n);
-        if (s.contains("3") || s.contains("4") || s.contains("7")) {
-            return false;
-        }
-        
-        StringBuilder sb = new StringBuilder("");
-
-        for (char c : s.toCharArray()) {
-            if (c == '2') {
-                sb.append('5');
-            }
-            else if (c == '5') {
-                sb.append('2');
-            }
-            else if (c == '6') {
-                sb.append('9');
-            }
-            else if (c == '9') {
-                sb.append('6');
-            }
-            else {
-                sb.append(c);
-            }
-        }
-        
-        return !sb.toString().equals(s)
-	}
-}
\ No newline at end of file
+    return count;
+  } 
+  
+  private boolean isGood(String num) {
+    StringBuilder sb = new StringBuilder();
+    for (char c : num.toCharArray()) {
+      if (c == '0' || c == '1' || c == '8') {
+        sb.append(c);
+      }
+      else if (c == '2' || c == '5') {
+        sb.append(c == '2' ? '5' : '2');
+      }
+      else if (c == '6' || c == '9') {
+        sb.append(c == '6' ? '9' : '6');
+      }
+      else {
+        return false;
+      }
+    }
+    return !sb.toString().equals(num);
+  }
+}
diff --git a/Medium/Boundary of Binary Tree.java b/Medium/Boundary of Binary Tree.java
index 41aa86ea..565dc467 100644
--- a/Medium/Boundary of Binary Tree.java	
+++ b/Medium/Boundary of Binary Tree.java	
@@ -8,50 +8,53 @@
  * }
  */
 class Solution {
+  List<Integer> list;
+  List<Integer> rightVal;
   public List<Integer> boundaryOfBinaryTree(TreeNode root) {
-    List<Integer> list = new ArrayList<>();
-    List<Integer> right = new ArrayList<>();
+    list = new ArrayList<>();
+    rightVal = new ArrayList<>();
     if (root == null) {
       return list;
     }
+    if (root.left == null && root.right == null) {
+      list.add(root.val);
+      return list;
+    }
     list.add(root.val);
-    addLeft(root.left, list);
-    addLeaves(root.left, list);
-    addLeaves(root.right, list);
-    addRight(root.right, right);
-    for (int i = right.size() - 1; i >= 0; i--) {
-      list.add(right.get(i));
+    addLeft(root.left);
+    addLeaves(root);
+    addRight(root.right);
+    for (int i = rightVal.size() - 1; i >= 0; i--) {
+      list.add(rightVal.get(i));
     }
     return list;
   }
   
-  private void addLeft(TreeNode root, List<Integer> list) {
-    if (root == null || (root.left == null && root.right == null)) {
-      return;
-    }
-    list.add(root.val);
-    addLeft(root.left == null ? root.right : root.left, list);
-  }
-  
-  private void addRight(TreeNode root, List<Integer> list) {
-    if (root == null || (root.left == null && root.right == null)) {
+  private void addLeft(TreeNode left) {
+    if (left == null || (left.left == null && left.right == null)) {
       return;
     }
-    list.add(root.val);
-    TreeNode next = root.right == null ? root.left : root.right;
-    addRight(root.right == null ? root.left : root.right, list);
+    list.add(left.val);
+    addLeft(left.left == null ? left.right : left.left);
   }
   
-  private void addLeaves(TreeNode root, List<Integer> list) {
+  private void addLeaves(TreeNode root) {
     if (root == null) {
       return;
     }
     if (root.left == null && root.right == null) {
       list.add(root.val);
+      return;
     }
-    else {
-      addLeaves(root.left, list);
-      addLeaves(root.right, list);
+    addLeaves(root.left);
+    addLeaves(root.right);
+  }
+  
+  private void addRight(TreeNode right) {
+    if (right == null || (right.left == null && right.right == null)) {
+      return;
     }
+    rightVal.add(right.val);
+    addRight(right.right == null ? right.left : right.right);
   }
 }
diff --git a/Medium/Distribute Coins in Binary Tree.java b/Medium/Distribute Coins in Binary Tree.java
index bab8bb39..e2b15fd4 100644
--- a/Medium/Distribute Coins in Binary Tree.java	
+++ b/Medium/Distribute Coins in Binary Tree.java	
@@ -8,30 +8,20 @@
  * }
  */
 class Solution {
-    int numOfSteps;
-    public int distributeCoins(TreeNode root) {
-        numOfSteps = 0;
-        postorder(root);
-        
-        return numOfSteps;
-    }
-    
-    private int postorder(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        
-        int coin = postorder(root.left) + postorder(root.right);
-        
-        if (root.val == 0) {
-            coin += -1;
-        }
-        else {
-            coin += root.val - 1;
-        }
-        
-        numOfSteps += Math.abs(coin);
-        
-        return coin;
+  int ans;
+  public int distributeCoins(TreeNode root) {
+    ans = 0;
+    dfs(root);
+    return ans;
+  }
+  
+  private int dfs(TreeNode root) {
+    if (root == null) {
+      return 0;
     }
+    int l = dfs(root.left);
+    int r = dfs(root.right);
+    ans += Math.abs(l) + Math.abs(r);
+    return root.val + l + r - 1;
+  }
 }
diff --git a/Medium/Implement Trie (Prefix Tree).java b/Medium/Implement Trie (Prefix Tree).java
index fa3d1c71..f987662b 100644
--- a/Medium/Implement Trie (Prefix Tree).java	
+++ b/Medium/Implement Trie (Prefix Tree).java	
@@ -1,69 +1,73 @@
 class Trie {
 
-    Node trie;
-    /** Initialize your data structure here. */
-    public Trie() {
-        trie = new Node("");
-    }
-
-    /** Inserts a word into the trie. */
-    public void insert(String word) {
-        Node curr = trie;
-        for(int i=0; i<word.length(); i++) {
-            if (!curr.childrens.containsKey(word.charAt(i))) {
-                curr.childrens.put(word.charAt(i), new Node(word.substring(0, i+1)));
-            }
+  /** Initialize your data structure here. */
+  Node root;
+  public Trie() {
+    root = new Node('-');
+  }
 
-            curr = curr.childrens.get(word.charAt(i));
-
-            if (i == word.length() - 1) {
-                curr.isWord = true;
-            }
-        }
+  /** Inserts a word into the trie. */
+  public void insert(String word) {
+    insertHelper(word, 0, root);
+  }
+  
+  private void insertHelper(String word, int idx, Node root) {
+    if (idx >= word.length()) {
+      root.isWord = true;
+      return;
     }
-
-    /** Returns if the word is in the trie. */
-    public boolean search(String word) {
-        Node curr = trie;
-        for (int i=0; i<word.length(); i++) {
-            if (curr.childrens.containsKey(word.charAt(i))) {
-                curr = curr.childrens.get(word.charAt(i));
-            }
-            else {
-                return false;
-            }
-        }
-
-        return curr.isWord;
+    if (!root.children.containsKey(word.charAt(idx))) {
+      root.children.put(word.charAt(idx), new Node(word.charAt(idx)));
     }
+    root = root.children.get(word.charAt(idx));
+    insertHelper(word, idx + 1, root);
+  }
 
-    /** Returns if there is any word in the trie that starts with the given prefix. */
-    public boolean startsWith(String prefix) {
-        Node curr = trie;
-
-        for (int i=0; i<prefix.length(); i++) {
-            if (curr.childrens.containsKey(prefix.charAt(i))) {
-                curr = curr.childrens.get(prefix.charAt(i));
-            }
-            else {
-                return false;
-            }
-        }
-
-        return true;
+  /** Returns if the word is in the trie. */
+  public boolean search(String word) {
+    return searchHelper(word, 0, root);
+  }
+  
+  private boolean searchHelper(String word, int idx, Node root) {
+    if (idx == word.length()) {
+      return root.isWord;
     }
+    if (!root.children.containsKey(word.charAt(idx))) {
+      return false;
+    }
+    root = root.children.get(word.charAt(idx));
+    return searchHelper(word, idx + 1, root);
+  }
 
-    private static final class Node {
-        String prefix;
-        Map<Character, Node> childrens;
-        boolean isWord;
-
-        public Node(String prefix) {
-            this.prefix = prefix;
-            this.childrens = new HashMap<>();
-        }
+  /** Returns if there is any word in the trie that starts with the given prefix. */
+  public boolean startsWith(String prefix) {
+    return startsWithHelper(prefix, 0, root);
+  }
+  
+  private boolean startsWithHelper(String word, int idx, Node root) {
+    if (idx == word.length()) {
+      return true;
+    }
+    if (!root.children.containsKey(word.charAt(idx))) {
+      return false;
     }
+    root = root.children.get(word.charAt(idx));
+    return startsWithHelper(word, idx + 1, root);
+  }
 }
+
+class Node {
+  char val;
+  Map<Character, Node> children;
+  boolean isWord;
+  
+  public Node(char val) {
+    this.val = val;
+    children = new HashMap<>();
+    isWord = false;
+  }
+}
+
 /**
  * Your Trie object will be instantiated and called as such:
  * Trie obj = new Trie();
diff --git a/Medium/Inorder Successor in BST.java b/Medium/Inorder Successor in BST.java
index a69355e3..62b37697 100644
--- a/Medium/Inorder Successor in BST.java	
+++ b/Medium/Inorder Successor in BST.java	
@@ -8,35 +8,26 @@
  * }
  */
 class Solution {
-    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
-        if (p.right != null) {
-            TreeNode node = p.right;
-            while (node.left != null) {
-                node = node.left;
-            }
-            
-            return node;
-        }
-        
-        return getLastLeft(root, p);
+  public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
+    if (p.right != null) {
+      TreeNode node = p.right;
+      while (node.left != null) {
+        node = node.left;
+      }
+      return node;
     }
-
-    private TreeNode getLastLeft(TreeNode root, TreeNode p) {
-        TreeNode lastLeft = null;
-        
-        while (root != null) {
-            if (root == p) {
-                break;
-            }
-            else if (root.val < p.val) {
-                root = root.right;
-            }
-            else {
-                lastLeft = root;
-                root = root.left;
-            }
+    else {
+      TreeNode lastLeft = null;
+      while (root != p) {
+        if (root.val > p.val) {
+          lastLeft = root;
+          root = root.left;
+        }
+        else {
+          root = root.right;
         }
-        
-        return lastLeft;
+      }
+      return lastLeft;
     }
+  }
 }
diff --git a/Medium/Knight Dialer.java b/Medium/Knight Dialer.java
new file mode 100644
index 00000000..bebd4576
--- /dev/null
+++ b/Medium/Knight Dialer.java	
@@ -0,0 +1,41 @@
+class Solution {
+  public static final int max = (int) Math.pow(10, 9) + 7;
+
+  public int knightDialer(int n) {
+     // A 3D array to store the solutions to the subproblems
+     long M[][][] = new long[n + 1][4][3];
+     long s = 0;
+     //do n hops from every i, j index (the very requirement of the problem)
+     for(int i = 0; i < 4; i++) {
+        for(int j = 0; j < 3; j++) {
+           s = (s + paths(M, i, j, n)) % max;
+        }
+     }
+     return (int) s;
+  }
+
+  private long paths(long[][][] M, int i, int j, int n) {
+   // if the knight hops outside of the matrix or to * return 0 
+   //as there are no unique paths from here
+   if(i < 0 || j < 0 || i >= 4 || j >= 3 || (i == 3 && j != 1)) {
+     return 0;
+   }
+   if(n == 1) {
+     return 1;
+   }
+   //if the subproblem's solution is already computed, then return it
+   if(M[n][i][j] > 0) {
+     return M[n][i][j];
+   }
+   //else compute the subproblem's solution and save it in memory
+   M[n][i][j] = paths(M, i - 1, j - 2, n - 1) % max + // jump to a
+                paths(M, i - 2, j - 1, n - 1) % max + // jump to b
+                paths(M, i - 2, j + 1, n - 1) % max + // jump to c
+                paths(M, i - 1, j + 2, n - 1) % max + // jump to d
+                paths(M, i + 1, j + 2, n - 1) % max + // jump to e
+                paths(M, i + 2, j + 1, n - 1) % max + // jump to f
+                paths(M, i + 2, j - 1, n - 1) % max + // jump to g
+                paths(M, i + 1, j - 2, n - 1) % max; // jump to h
+   return M[n][i][j];
+  }
+}

From 6b4da91e5b5d2549bada06e5888737733af0d81c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 24 Feb 2020 19:44:24 -0800
Subject: [PATCH 0110/2175] Added 1 solution & modified 6 solutions

---
 Easy/Reverse words in a String III.java       |  33 ++-
 Medium/Design Circular Deque.java             | 202 ++++++++----------
 Medium/Find the duplicate number.java         |  31 +--
 ...ufficient Nodes in Root to Leaf Paths.java |  23 +-
 ...inimum Domino Rotations For Equal Row.java |  21 ++
 ...of Nodes with Even-Valued Grandparent.java |  19 +-
 Medium/Swap Nodes in Pair.java                |  40 ++--
 7 files changed, 192 insertions(+), 177 deletions(-)
 create mode 100644 Medium/Minimum Domino Rotations For Equal Row.java

diff --git a/Easy/Reverse words in a String III.java b/Easy/Reverse words in a String III.java
index 1faf9983..e50dd770 100644
--- a/Easy/Reverse words in a String III.java	
+++ b/Easy/Reverse words in a String III.java	
@@ -1,12 +1,23 @@
-public class Solution {
-    public String reverseWords(String s) {
-        String[] words=s.split("\\s");
-        for (int i=0;i<words.length;i++) {
-            StringBuilder input1 = new StringBuilder();
-            input1.append(words[i]);
-            input1 = input1.reverse();
-            words[i] = input1.toString();
-        }
-        return String.join(" ", words);
+class Solution {
+  public String reverseWords(String s) {
+    int idx = 0;
+    int n = s.length();
+    StringBuilder sb = new StringBuilder();
+    int start = 0;
+    while (idx < n) {
+      while (idx < n && s.charAt(idx) != ' ') {
+        idx++;
+      }
+      int curr = idx - 1;
+      while (curr >= start) {
+        sb.append(s.charAt(curr--));
+      }
+      if (idx != n) {
+        sb.append(" ");
+      }
+      idx++;
+      start = idx;
     }
-}
\ No newline at end of file
+    return sb.toString();
+  }
+}
diff --git a/Medium/Design Circular Deque.java b/Medium/Design Circular Deque.java
index 5f6fe4c8..38b8650c 100644
--- a/Medium/Design Circular Deque.java	
+++ b/Medium/Design Circular Deque.java	
@@ -1,118 +1,106 @@
 class MyCircularDeque {
+  DequeNode head;
+  DequeNode tail;
+  int k;
+  int currCapacity;
 
-    /** Initialize your data structure here. Set the size of the deque to be k. */
-    Queue<Integer> main;
-    Queue<Integer> backup;
-    int capacity;
-    
-    public MyCircularDeque(int k) {
-        main = new LinkedList<>();
-        backup = new LinkedList<>();
-        capacity = k;
-    }
-    
-    /** Adds an item at the front of Deque. Return true if the operation is successful. */
-    public boolean insertFront(int value) {
-        if (main.size() == capacity) {
-            return false;
-        }
-        
-        while(!main.isEmpty()) {
-            backup.add(main.remove());
-        }
-        
-        main.add(value);
-        
-        while (!backup.isEmpty()) {
-            main.add(backup.remove());
-        }
-        
-        return true;
-    }
-    
-    /** Adds an item at the rear of Deque. Return true if the operation is successful. */
-    public boolean insertLast(int value) {
-        if (main.size() == capacity) {
-            return false;
-        }
-        
-        main.add(value);
-        
-        return true;
-    }
-    
-    /** Deletes an item from the front of Deque. Return true if the operation is successful. */
-    public boolean deleteFront() {
-        if (main.isEmpty()) {
-            return false;
-        }
-        
-        main.remove();
-        
-        return true;
+  /** Initialize your data structure here. Set the size of the deque to be k. */
+  public MyCircularDeque(int k) {
+    currCapacity = 0;
+    this.k = k;
+    head = new DequeNode(-1);
+    tail = new DequeNode(-1);
+    head.front = tail;
+    tail.back = head;
+  }
+
+  /** Adds an item at the front of Deque. Return true if the operation is successful. */
+  public boolean insertFront(int value) {
+    if (isFull()) {
+      return false;
     }
-    
-    /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
-    public boolean deleteLast() {
-        if (main.isEmpty()) {
-            return false;
-        }
-        
-        while(!main.isEmpty()) {
-            backup.add(main.remove());
-        }
-        
-        int size = backup.size();
-        
-        while (size-- > 1) {
-            main.add(backup.remove());
-        }
-        
-        backup.remove();
-        
-        return true;
+    DequeNode node = new DequeNode(value);
+    node.front = head.front;
+    head.front.back = node;
+    node.back = head;
+    head.front = node;
+    currCapacity++;
+    return true;
+  }
+
+  /** Adds an item at the rear of Deque. Return true if the operation is successful. */
+  public boolean insertLast(int value) {
+    if (isFull()) {
+      return false;
     }
-    
-    /** Get the front item from the deque. */
-    public int getFront() {
-        if (main.isEmpty()) {
-            return -1;
-        }
-        
-        return main.peek();
+    DequeNode node = new DequeNode(value);
+    node.front = tail;
+    node.back = tail.back;
+    tail.back.front = node;
+    tail.back = node;
+    currCapacity++;
+    return true;
+  }
+
+  /** Deletes an item from the front of Deque. Return true if the operation is successful. */
+  public boolean deleteFront() {
+    if (isEmpty()) {
+      return false;
     }
-    
-    /** Get the last item from the deque. */
-    public int getRear() {
-        if (main.isEmpty()) {
-            return -1;
-        }
-        
-        while(!main.isEmpty()) {
-            backup.add(main.remove());
-        }
-        
-        int size = backup.size();
-        
-        while (size-- > 1) {
-            main.add(backup.remove());
-        }
-        
-        int ans = backup.peek();
-        main.add(backup.remove());
-        
-        return ans;
+    DequeNode next = head.front.front;
+    head.front = next;
+    next.back = head;
+    currCapacity--;
+    return true;
+  }
+
+  /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
+  public boolean deleteLast() {
+    if (isEmpty()) {
+      return false;
     }
-    
-    /** Checks whether the circular deque is empty or not. */
-    public boolean isEmpty() {
-        return main.isEmpty();
+    DequeNode prev = tail.back.back;
+    tail.back = prev;
+    prev.front = tail;
+    currCapacity--;
+    return true;
+  }
+
+  /** Get the front item from the deque. */
+  public int getFront() {
+    if (isEmpty()) {
+      return -1;
     }
-    
-    /** Checks whether the circular deque is full or not. */
-    public boolean isFull() {
-        return main.size() == capacity;
+    return head.front.val;
+  }
+
+  /** Get the last item from the deque. */
+  public int getRear() {
+    if (isEmpty()) {
+      return -1;
     }
+    return tail.back.val;
+  }
+
+  /** Checks whether the circular deque is empty or not. */
+  public boolean isEmpty() {
+    return currCapacity == 0;
+  }
+
+  /** Checks whether the circular deque is full or not. */
+  public boolean isFull() {
+    return currCapacity == k;
+  }
+}
+
+class DequeNode {
+  int val;
+  DequeNode front;
+  DequeNode back;
+  
+  public DequeNode(int val) {
+    this.val = val;
+  }
 }
 
 /**
diff --git a/Medium/Find the duplicate number.java b/Medium/Find the duplicate number.java
index e4387706..d05d0a60 100644
--- a/Medium/Find the duplicate number.java	
+++ b/Medium/Find the duplicate number.java	
@@ -1,17 +1,20 @@
 class Solution {
-    public int findDuplicate(int[] nums) {
-        int n = nums.length;
-        int slow = n;
-        int fast = n;
-        do{
-            slow = nums[slow-1];
-            fast = nums[nums[fast-1]-1];
-        }while (slow != fast);
-        slow = n;
-        while (slow != fast) {
-            slow = nums[slow-1];
-            fast = nums[fast-1];
-        }
-        return slow;
+  public int findDuplicate(int[] nums) {
+    int tortoise = nums[0];
+    int hare = nums[0];
+    while(true) {
+      tortoise = nums[tortoise];
+      hare = nums[nums[hare]];
+      if (tortoise == hare) {
+        break;
+      }
     }
+    int p1 = nums[0];
+    int p2 = tortoise;
+    while (p1 != p2) {
+      p1 = nums[p1];
+      p2 = nums[p2];
+    }
+    return p1;
+  }
 }
diff --git a/Medium/Insufficient Nodes in Root to Leaf Paths.java b/Medium/Insufficient Nodes in Root to Leaf Paths.java
index 84f8682b..7f1c80ce 100644
--- a/Medium/Insufficient Nodes in Root to Leaf Paths.java	
+++ b/Medium/Insufficient Nodes in Root to Leaf Paths.java	
@@ -8,18 +8,15 @@
  * }
  */
 class Solution {
-    public TreeNode sufficientSubset(TreeNode root, int limit) {
-        if (root == null) {
-            return null;
-        }
-        
-        if (root.left == null && root.right == null) {
-            return root.val < limit ? null : root;
-        }
-        
-        root.left = sufficientSubset(root.left, limit - root.val);
-        root.right = sufficientSubset(root.right, limit - root.val);
-        
-        return root.left == root.right ? null : root;
+  public TreeNode sufficientSubset(TreeNode root, int limit) {
+    if (root == null) {
+      return null;
     }
+    if (root.left == null && root.right == null) {
+      return root.val < limit ? null : root;
+    }
+    root.left = sufficientSubset(root.left, limit - root.val);
+    root.right = sufficientSubset(root.right, limit - root.val);
+    return root.left == root.right ? null : root;
+  }
 }
diff --git a/Medium/Minimum Domino Rotations For Equal Row.java b/Medium/Minimum Domino Rotations For Equal Row.java
new file mode 100644
index 00000000..1ed001ae
--- /dev/null
+++ b/Medium/Minimum Domino Rotations For Equal Row.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int minDominoRotations(int[] A, int[] B) {
+    int[] counterA = new int[7];
+    int[] counterB = new int[7];
+    int[] same = new int[7];
+    int n = A.length;
+    for (int i = 0; i < n; i++) {
+      counterA[A[i]]++;
+      counterB[B[i]]++;
+      if (A[i] == B[i]) {
+        same[A[i]]++;
+      }
+    }
+    for (int i = 1; i < 7; i++) {
+      if (counterA[i] + counterB[i] - same[i] == n) {
+        return n - Math.max(counterA[i], counterB[i]);
+      }
+    }
+    return -1;
+  }
+}
diff --git a/Medium/Sum of Nodes with Even-Valued Grandparent.java b/Medium/Sum of Nodes with Even-Valued Grandparent.java
index e872e123..d2519a60 100644
--- a/Medium/Sum of Nodes with Even-Valued Grandparent.java	
+++ b/Medium/Sum of Nodes with Even-Valued Grandparent.java	
@@ -8,22 +8,21 @@
  * }
  */
 class Solution {
+  int sum;
   public int sumEvenGrandparent(TreeNode root) {
-    int[] ans = {0};
-    helper(root, -1, -1, ans);
-    return ans[0];
+    sum = 0;
+    helper(root, null, null);
+    return sum;
   }
   
-  private void helper(TreeNode root, int parent, int grandparent, int[] ans) {
+  private void helper(TreeNode root, TreeNode parent, TreeNode grandparent) {
     if (root == null) {
       return;
     }
-    if (grandparent > 0 && grandparent % 2 == 0) {
-      ans[0] += root.val;
+    if (grandparent != null && grandparent.val % 2 == 0) {
+      sum += root.val;
     }
-    grandparent = parent;
-    parent = root.val;
-    helper(root.left, parent, grandparent, ans);
-    helper(root.right, parent, grandparent, ans);
+    helper(root.left, root, parent);
+    helper(root.right, root, parent);
   }
 }
diff --git a/Medium/Swap Nodes in Pair.java b/Medium/Swap Nodes in Pair.java
index 2135fb05..478438f6 100644
--- a/Medium/Swap Nodes in Pair.java	
+++ b/Medium/Swap Nodes in Pair.java	
@@ -7,27 +7,23 @@
  * }
  */
 class Solution {
-    public ListNode swapPairs(ListNode head) {
-        if(head == null || head.next == null) return head;
-        
-        ListNode temp = head.next;
-        ListNode prev = null;
-        
-        while(head != null && head.next != null) {
-            
-            if(prev != null) {
-                prev.next = head.next;
-            }
-            
-            ListNode temp1 = head.next;
-            ListNode temp2 = head;
-            head.next = head.next.next;
-            head = temp1;
-            head.next = temp2;
-            prev = head.next;
-            head = head.next.next;
-        }
-        
-        return temp;
+  public ListNode swapPairs(ListNode head) {
+    if (head == null || head.next == null) {
+      return head;
     }
+    ListNode next = head.next;
+    head.next = swapPairs(head.next.next);
+    next.next = head;
+    return next;
+  }
+  
+  private ListNode reverseHeadPair(ListNode head) {
+    if (head == null || head.next == null) {
+      return head;
+    }
+    ListNode next = head.next;
+    head.next = reverseHeadPair(head.next.next);
+    next.next = head;
+    return next;
+  }
 }

From 7ad8f8da74f153634a5f43d2ec4dd8d1a8c8326e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 26 Feb 2020 08:40:33 -0800
Subject: [PATCH 0111/2175] Modified one solution

---
 Medium/Delete Nodes And Return Forest.java | 69 +++++++++++-----------
 1 file changed, 34 insertions(+), 35 deletions(-)

diff --git a/Medium/Delete Nodes And Return Forest.java b/Medium/Delete Nodes And Return Forest.java
index 8c4206cf..b65710bc 100644
--- a/Medium/Delete Nodes And Return Forest.java	
+++ b/Medium/Delete Nodes And Return Forest.java	
@@ -8,43 +8,42 @@
  * }
  */
 class Solution {
-    List<TreeNode> forest;
-    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
-        forest = new ArrayList<>();
-        Set<Integer> toDelete = new HashSet<>();
-        for (int val : to_delete) {
-            toDelete.add(val);
-        }
-        
-        helper(root, toDelete);
-        
-        if (!toDelete.contains(root.val)) {
-            forest.add(root);
-        }
-        
-        return forest;
+  public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
+    List<TreeNode> forest = new ArrayList<>();
+    Set<Integer> set = new HashSet<>();
+    for (int num : to_delete) {
+      set.add(num);
     }
-    
-    private TreeNode helper(TreeNode root, Set<Integer> toDelete) {
-        if (root == null) {
-            return null;
+    helper(root, set, forest, null, 0);
+    return forest;
+  }
+  
+  private void helper(TreeNode root, Set<Integer> set, List<TreeNode> forest, TreeNode parent, int side) {
+    if (root == null) {
+      return;
+    }
+    // Deletion 
+    if (set.contains(root.val)) {
+      if (parent != null) { 
+        // Decide which node we want to make null based on side
+        if (side == -1) {
+          parent.left = null;
         }
-        
-        root.left = helper(root.left, toDelete);
-        root.right = helper(root.right, toDelete);
-        
-        if (toDelete.contains(root.val)) {
-            if (root.left != null) {
-                forest.add(root.left);
-            }
-            
-            if (root.right != null) {
-                forest.add(root.right);
-            }
-            
-            return null;
+        else {
+          parent.right = null;
         }
-        
-        return root;
+      } 
+      // Call the recursive function for left & right with parent as null as we deleted the node
+      helper(root.left, set, forest, null, 0);
+      helper(root.right, set, forest, null, 0);
+    }
+    // No Deletion
+    else {
+      if (parent == null) { // Don't add if we have already added the parent and this is a child node
+        forest.add(root);
+      }  
+      helper(root.left, set, forest, root, -1);
+      helper(root.right, set, forest, root, 1);
     }
+  }
 }

From f1fe4ef91d5235b537322eebdf6fed734653e62b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 26 Feb 2020 20:09:01 -0800
Subject: [PATCH 0112/2175] added 3 solutions & modified 5 solutions

---
 Easy/Min Stack.java                      | 51 ++++++++++-----------
 Easy/Valid Parantheses.java              | 46 +++++++++----------
 Medium/Add Two Numbers.java              | 58 ++++++++++--------------
 Medium/Group Anagrams.java               | 19 ++++++++
 Medium/Product of Array Except self.java | 29 ++++++------
 Medium/Search a 2D Matrix.java           | 50 +++++++-------------
 Medium/Validate Binary Search Tree.java  | 26 +++++++++++
 Medium/Validate Stack Sequences.java     | 29 ++++++++++++
 8 files changed, 175 insertions(+), 133 deletions(-)
 create mode 100644 Medium/Group Anagrams.java
 create mode 100644 Medium/Validate Binary Search Tree.java
 create mode 100644 Medium/Validate Stack Sequences.java

diff --git a/Easy/Min Stack.java b/Easy/Min Stack.java
index 9cd99eb9..108f5e0c 100644
--- a/Easy/Min Stack.java	
+++ b/Easy/Min Stack.java	
@@ -1,33 +1,30 @@
 class MinStack {
 
-    public int min = Integer.MAX_VALUE;
-    public Stack<Integer> stack = new Stack<Integer>();
     /** initialize your data structure here. */
-    public MinStack() {
-        
-    }
-    
-    public void push(int x) {
-        if (x<=min) {
-            stack.push(min);
-            min = x;
-        }
-        stack.push(x);
-    }
-    
-    public void pop() {
-        if(stack.pop() == min) {
-            min=stack.pop();
-        }
-    }
-    
-    public int top() {
-        return stack.peek();
-    }
-    
-    public int getMin() {
-        return min;
-    }
+  Stack<Integer> stack;
+  Stack<Integer> min;
+  public MinStack() {
+    stack = new Stack<>();
+    min = new Stack<>();
+  }
+
+  public void push(int x) {
+    stack.push(x);
+    min.push(Math.min(x, min.isEmpty() ? Integer.MAX_VALUE : min.peek()));
+  }
+
+  public void pop() {
+    stack.pop();
+    min.pop();
+  }
+
+  public int top() {
+    return stack.peek();
+  }
+
+  public int getMin() {
+    return min.peek();
+  }
 }
 
 /**
diff --git a/Easy/Valid Parantheses.java b/Easy/Valid Parantheses.java
index 6991cd9f..4f6d95b3 100644
--- a/Easy/Valid Parantheses.java	
+++ b/Easy/Valid Parantheses.java	
@@ -1,28 +1,26 @@
 class Solution {
-    public Map<Character, Character> map = new HashMap<Character, Character>(){{
-        put('{', '}');
-        put('[', ']');
-        put('(', ')');
-    }};
-
-    public boolean isValid(String s) {
-        Stack<Character> stack = new Stack<>();
-        for (char c : s.toCharArray()) {
-            if (map.containsKey(c)) {
-                stack.push(c);
-            }
-            else {
-                if (stack.isEmpty()) {
-                    return false;
-                }
-
-                char removed = stack.pop();
-                if (map.get(removed) != c) {
-                    return false;
-                }
-            }
+  public boolean isValid(String s) {
+    Stack<Character> stack = new Stack<>();
+    String closing = ")}]";
+    String opening = "({[";
+    
+    for (char c : s.toCharArray()) {
+      if (closing.indexOf(c) == -1) {
+        stack.push(c);
+      }
+      else {
+        if (stack.isEmpty()) {
+          System.out.println("HERE");
+          return false;
         }
-
-        return stack.isEmpty();
+        char temp = stack.pop();
+        if (opening.indexOf(temp) != closing.indexOf(c)) {
+          System.out.println(opening.indexOf(temp) + " " + closing.indexOf(c));
+          return false;
+        }
+      }
     }
+    System.out.println(stack);
+    return stack.isEmpty();
+  }
 }
diff --git a/Medium/Add Two Numbers.java b/Medium/Add Two Numbers.java
index 38a32906..4917bf04 100644
--- a/Medium/Add Two Numbers.java	
+++ b/Medium/Add Two Numbers.java	
@@ -7,38 +7,30 @@
  * }
  */
 class Solution {
-    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-        ListNode ans = new ListNode(-1);
-        ListNode curr = ans;
-        int carry = 0;
-        
-        while (l1 != null || l2 != null) {
-            int temp = carry;
-            if (l1 != null && l2 != null) {
-                temp += l1.val + l2.val;
-                l1 = l1.next;
-                l2 = l2.next;  
-            }    
-            else if (l1 != null && l2 == null) {
-                temp += l1.val;
-                l1 = l1.next;
-            }
-            else {
-                temp += l2.val;
-                l2 = l2.next;   
-            }
-            
-            carry = temp > 9 ? temp / 10 : 0;
-            temp = temp > 9 ? temp % 10 : temp;
-            
-            curr.next = new ListNode(temp);
-            curr = curr.next;
-        }
-        
-        if (carry > 0) {
-            curr.next = new ListNode(carry);
-        }
-        
-        return ans.next;
+  public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+    ListNode ans = new ListNode(-1);
+    ListNode curr = ans;
+    int carry = 0;
+    while (l1 != null || l2 != null || carry > 0) {
+      int temp = carry;
+      if (l1 != null && l2 != null) {
+        temp += l1.val + l2.val;
+        l1 = l1.next;
+        l2 = l2.next;
+      }
+      else if (l1 != null && l2 == null) {
+        temp += l1.val;
+        l1 = l1.next;
+      }
+      else if (l1 == null && l2 != null) {
+        temp += l2.val;
+        l2 = l2.next;
+      }
+      carry = temp > 9 ? temp / 10 : 0;
+      temp = temp % 10;
+      curr.next = new ListNode(temp);
+      curr = curr.next;
     }
+    return ans.next;
+  }
 }
diff --git a/Medium/Group Anagrams.java b/Medium/Group Anagrams.java
new file mode 100644
index 00000000..dcdac935
--- /dev/null
+++ b/Medium/Group Anagrams.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public List<List<String>> groupAnagrams(String[] strs) {
+    Map<String, List<String>> map = new HashMap<>();
+    for (String str : strs) {
+      map.computeIfAbsent(sortedStr(str), k -> new ArrayList<>()).add(str);
+    }
+    List<List<String>> ans = new ArrayList<>();
+    for (String key : map.keySet()) {
+      ans.add(map.get(key));
+    }
+    return ans;
+  }
+  
+  private String sortedStr(String s) {
+    char[] chars = s.toCharArray();
+    Arrays.sort(chars);
+    return String.valueOf(chars);
+  }
+}
diff --git a/Medium/Product of Array Except self.java b/Medium/Product of Array Except self.java
index 8bf5e870..44306f8b 100644
--- a/Medium/Product of Array Except self.java	
+++ b/Medium/Product of Array Except self.java	
@@ -1,19 +1,16 @@
 class Solution {
-    public int[] productExceptSelf(int[] nums) {
-        
-        int[] ans = new int[nums.length];
-
-        for (int i = 0, tmp = 1; i < nums.length; i++) {
-            ans[i] = tmp;
-            tmp *= nums[i];
-        }
-        
-        for (int i = nums.length - 1, tmp = 1; i >= 0; i--) {
-            ans[i] *= tmp;
-            tmp *= nums[i];
-        }
-        
-        return ans;
-        
+  public int[] productExceptSelf(int[] nums) {
+    int[] ans = new int[nums.length];
+    int mul = 1;
+    for (int i = 0; i < nums.length; i++) {
+      ans[i] = mul;
+      mul *= nums[i];
     }
+    mul = 1;
+    for (int i = nums.length - 1; i >= 0; i--) {
+      ans[i] *= mul;
+      mul *= nums[i];
+    }
+    return ans;
+  }
 }
diff --git a/Medium/Search a 2D Matrix.java b/Medium/Search a 2D Matrix.java
index 1c8b5722..7375d4f3 100644
--- a/Medium/Search a 2D Matrix.java	
+++ b/Medium/Search a 2D Matrix.java	
@@ -1,37 +1,21 @@
 class Solution {
-    public boolean searchMatrix(int[][] matrix, int target) {
-        if (matrix.length == 0 || matrix[0].length == 0) {
-            return false;
-        }
-        
-        if (target < matrix[0][0] || target > matrix[matrix.length-1][matrix[matrix.length-1].length - 1]) {
-            return false;
-        }
-        
-        int i=0;
-        for (i=0; i<matrix.length-1; i++) {
-            if (target >= matrix[i][0] && target < matrix[i+1][0]) {
-                return binarySearch(matrix[i], 0, matrix[i].length-1, target);
-            }
-        }
-        
-        return binarySearch(matrix[i], 0, matrix[i].length-1, target);
+  public boolean searchMatrix(int[][] matrix, int target) {
+    if (matrix.length == 0 || matrix[0].length == 0) {
+      return false;
     }
-    
-    private boolean binarySearch(int[] arr, int start, int end, int target) {
-        while (start <= end) {
-            int mid = (start + end)/2;
-            if (arr[mid] == target) {
-                return true;
-            }
-            else if (arr[mid] > target) {
-                end = mid - 1;
-            }
-            else {
-                start = mid + 1;
-            }
-        }
-        
-        return false;
+    int row = matrix.length - 1;
+    int col = 0;
+    while (row >= 0 && col < matrix[0].length) {
+      if (matrix[row][col] == target) {
+        return true;
+      }
+      else if (matrix[row][col] > target) {
+        row--;
+      }
+      else {
+        col++;
+      }
     }
+    return false;
+  }
 }
diff --git a/Medium/Validate Binary Search Tree.java b/Medium/Validate Binary Search Tree.java
new file mode 100644
index 00000000..b7d2a9f7
--- /dev/null
+++ b/Medium/Validate Binary Search Tree.java	
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  public boolean isValidBST(TreeNode root) {
+    long min = (long) Integer.MIN_VALUE;
+    long max = (long) Integer.MAX_VALUE;
+    return helper(root, min - 1, max + 1);
+  }
+  
+  private boolean helper(TreeNode root, long min, long max) {
+    if (root == null) {
+      return true;
+    }
+    if (root.val <= min || root.val >= max) {
+      return false;
+    }
+    return helper(root.left, min, (long) root.val) && helper(root.right, (long) root.val, max);
+  }
+}
diff --git a/Medium/Validate Stack Sequences.java b/Medium/Validate Stack Sequences.java
new file mode 100644
index 00000000..aa3c8470
--- /dev/null
+++ b/Medium/Validate Stack Sequences.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public boolean validateStackSequences(int[] pushed, int[] popped) {
+    int pushStart = 0;
+    int popStart = 0;
+    Stack<Integer> stack = new Stack<>();
+    while (pushStart < pushed.length && popStart < popped.length) {
+      if (stack.isEmpty()) {
+        stack.push(pushed[pushStart++]);
+      }
+      else {
+        if (stack.peek() == popped[popStart]) {
+          stack.pop();
+          popStart++;
+        }
+        else {
+          stack.push(pushed[pushStart++]);
+        }
+      }
+    }
+    while (popStart < popped.length) {
+      if (stack.peek() != popped[popStart]) {
+        return false;
+      }
+      stack.pop();
+      popStart++;
+    }
+    return true;
+  }
+}

From ab92d04b38051820076f0d16e0ba76a5b032b51c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 28 Feb 2020 09:49:54 -0800
Subject: [PATCH 0113/2175] Modified 2 solutions

---
 Easy/Shortest Distance to a Character.java | 50 ++++++++--------------
 Medium/Subarray Sum Equals K.java          | 24 +++++------
 2 files changed, 28 insertions(+), 46 deletions(-)

diff --git a/Easy/Shortest Distance to a Character.java b/Easy/Shortest Distance to a Character.java
index 73ebfa5d..b053588f 100644
--- a/Easy/Shortest Distance to a Character.java	
+++ b/Easy/Shortest Distance to a Character.java	
@@ -1,36 +1,20 @@
 class Solution {
-    public static int[] shortestToChar(String S, char C) {
-    	int[] ans = new int[S.length()];
-    	
-    	int count = (int) S.chars().filter(ch -> ch == C).count();
-    	
-    	int[] Cindexes = new int[count];
-    	int[] indexes = new int[S.length()];
-    	
-    	int i = 0;
-    	
-    	for (int j=0; j<S.length(); j++) {
-    		if (S.charAt(j) == C) {
-    			Cindexes[i++] = j; 
-    		}
-    		
-    		indexes[j] = j;
-    	}
-    	
-    	for (int j=0; j<S.length(); j++) {
-    		ans[j] = findMin(Cindexes, indexes[j]);
-    	}
-    	
-    	return ans;
+  public int[] shortestToChar(String S, char C) {
+    int[] ans = new int[S.length()];
+    int prev = Integer.MIN_VALUE / 2;
+    for (int i = 0; i < S.length(); i++) {
+      if (S.charAt(i) == C) {
+        prev = i;
+      }
+      ans[i] = i - prev;
     }
-
-	private static int findMin(int[] cindexes, int i) {
-		int minDist = Integer.MAX_VALUE;
-		
-		for (int index : cindexes) {
-			minDist = Math.min(minDist, Math.abs(index - i));
-		}
-		
-		return minDist;
-	}
+    prev = Integer.MAX_VALUE / 2;
+    for (int i = S.length() - 1; i >= 0; i--) {
+      if (S.charAt(i) == C) {
+        prev = i;
+      }
+      ans[i] = Math.min(ans[i], prev - i);
+    }
+    return ans;
+  }
 }
diff --git a/Medium/Subarray Sum Equals K.java b/Medium/Subarray Sum Equals K.java
index 1a5b038a..03faa8e7 100644
--- a/Medium/Subarray Sum Equals K.java	
+++ b/Medium/Subarray Sum Equals K.java	
@@ -1,16 +1,14 @@
 class Solution {
-    public int subarraySum(int[] nums, int k) {
-        Map<Integer, Integer> map = new HashMap<>();
-        map.put(0, 1);
-        int count = 0;
-        int currentSum = 0;
-        
-        for (int num : nums) {
-            currentSum += num;
-            count += map.getOrDefault(currentSum - k, 0);
-            map.put(currentSum, map.getOrDefault(currentSum, 0) + 1);
-        }
-        
-        return count;
+  public int subarraySum(int[] nums, int k) {
+    int sum = 0;
+    int count = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    map.put(0, 1);
+    for (int i = 0; i < nums.length; i++) {
+      sum += nums[i];
+      count += map.getOrDefault(sum - k, 0);
+      map.put(sum, map.getOrDefault(sum, 0) + 1);
     }
+    return count;
+  }
 }

From 77e529135128bd60831fbab40f75355d781e456b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 29 Feb 2020 20:31:31 -0800
Subject: [PATCH 0114/2175] Added 1 solution & modified 2 solutions

---
 Easy/Baseball Game.java                       | 76 ++++++-------------
 ...ove All Adjacent Duplicates In String.java | 33 ++++----
 Medium/Rank Teams by Votes.java               | 33 ++++++++
 3 files changed, 77 insertions(+), 65 deletions(-)
 create mode 100644 Medium/Rank Teams by Votes.java

diff --git a/Easy/Baseball Game.java b/Easy/Baseball Game.java
index 48a8cc49..eb499246 100644
--- a/Easy/Baseball Game.java	
+++ b/Easy/Baseball Game.java	
@@ -1,54 +1,28 @@
 class Solution {
-    public int calPoints(String[] ops) {
-        int prev = Integer.MIN_VALUE;
-        int prevprev = Integer.MIN_VALUE;
-        Stack<Integer> st = new Stack<>();
-        int s = 0;
-        int j = 0;
-        
-        for (int i=0;i<ops.length;i++) {
-            if (ops[i].equals("D")) {
-                st.push(prev*2);
-                s += prev*2;
-                j++;
-                prevprev = prev;
-                prev = st.peek();
-            }
-            else if (ops[i].equals("C")) {
-                j--;
-                int t = st.pop();
-                s -= t;
-                if (j == 1) {
-                    prevprev = Integer.MIN_VALUE;
-                    prev = st.peek();
-                }
-                else if (j == 0) {
-                    prevprev = Integer.MIN_VALUE;
-                    prev = Integer.MIN_VALUE;
-                }
-                else {
-                    prev = st.peek();
-                    int k1 = st.pop();
-                    prevprev = st.pop();
-                    st.push(prevprev);
-                    st.push(k1);
-                }
-            }
-            else if (ops[i].equals("+")) {
-                st.push(prev + prevprev);
-                s += st.peek();
-                j++;
-                prevprev = prev;
-                prev = st.peek();
-            }
-            else {
-                st.push(Integer.parseInt(ops[i]));
-                j++;
-                prevprev = prev;
-                prev = st.peek();
-                s += st.peek();
-            }
-        }
-        return s;
+  public int calPoints(String[] ops) {
+    Stack<Integer> stack = new Stack<>();
+    int sum = 0;
+    for (String op : ops) {
+      if (op.equals("+")) {
+        int prev = stack.pop();
+        int prevToPrev = stack.peek();
+        int newScore = prev + prevToPrev;
+        sum += newScore;
+        stack.push(prev);
+        stack.push(newScore);
+      }
+      else if (op.equals("C")) {
+        sum -= stack.pop();
+      }
+      else if (op.equals("D")) {
+        sum += stack.peek() * 2;
+        stack.push(stack.peek() * 2);
+      }
+      else {
+        stack.push(Integer.parseInt(op));
+        sum += stack.peek();
+      }
     }
+    return sum;
+  }
 }
diff --git a/Easy/Remove All Adjacent Duplicates In String.java b/Easy/Remove All Adjacent Duplicates In String.java
index 005f780c..e0c7c46d 100644
--- a/Easy/Remove All Adjacent Duplicates In String.java	
+++ b/Easy/Remove All Adjacent Duplicates In String.java	
@@ -1,17 +1,22 @@
 class Solution {
-    public String removeDuplicates(String S) {
-        StringBuilder sb = new StringBuilder();
-        char[] chars = S.toCharArray();
-
-        for (char c : chars) {
-            if (sb.length() > 0 && sb.charAt(sb.length() - 1) == c) {
-                sb.deleteCharAt(sb.length() - 1);
-            }
-            else {
-                sb.append(c);
-            }
-        }
-
-        return sb.toString();
+  public String removeDuplicates(String S) {
+    Stack<Integer> stack = new Stack<>();
+    char[] chars = S.toCharArray();
+    for (int i = 0; i < S.length(); i++) {
+      if (stack.isEmpty() || chars[stack.peek()] != chars[i]) {
+        stack.push(i);
+      }
+      else {
+        chars[i] = '-';
+        chars[stack.pop()] = '-';
+      }
     }
+    StringBuilder sb = new StringBuilder();
+    for (char c : chars) {
+      if (c != '-') {
+        sb.append(c);
+      }
+    }
+    return sb.toString();
+  }
 }
diff --git a/Medium/Rank Teams by Votes.java b/Medium/Rank Teams by Votes.java
new file mode 100644
index 00000000..f7ced0c6
--- /dev/null
+++ b/Medium/Rank Teams by Votes.java	
@@ -0,0 +1,33 @@
+class Solution {
+  public String rankTeams(String[] votes) {
+    Map<Character, int[]> map = new HashMap<>();
+    int n = votes[0].length();
+    for(String vote : votes) {
+      for (int i = 0; i < n; i++) {
+        if (!map.containsKey(vote.charAt(i))) {
+          map.put(vote.charAt(i), new int[n]);
+        }
+        map.get(vote.charAt(i))[i]++;
+      }
+    }
+    PriorityQueue<Character> pq = new PriorityQueue<>(new Comparator<Character>(){
+      public int compare(Character c1, Character c2) {
+        for (int i = 0; i < n; i++) {
+          int c = map.get(c2)[i] - map.get(c1)[i];
+          if (c != 0) {
+            return c;
+          }
+        }
+        return c1 - c2;
+      }
+    });
+    for (char c : votes[0].toCharArray()) {
+      pq.add(c);
+    }
+    StringBuilder sb = new StringBuilder();
+    while (!pq.isEmpty()) {
+      sb.append(pq.poll());
+    }
+    return sb.toString();
+  }
+}

From c7eca3a6b258b7cfc810b2e9f8d7d01b7b9e94ea Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 1 Mar 2020 14:49:24 -0800
Subject: [PATCH 0115/2175] Added 2 solutions & modified 1 solution

---
 ...s Are Smaller Than the Current Number.java | 19 +++++++++
 Easy/Third Maximum Number.java                | 38 ++++++++++-------
 Medium/Linked List in Binary Tree.java        | 42 +++++++++++++++++++
 3 files changed, 83 insertions(+), 16 deletions(-)
 create mode 100644 Easy/How Many Numbers Are Smaller Than the Current Number.java
 create mode 100644 Medium/Linked List in Binary Tree.java

diff --git a/Easy/How Many Numbers Are Smaller Than the Current Number.java b/Easy/How Many Numbers Are Smaller Than the Current Number.java
new file mode 100644
index 00000000..5696318a
--- /dev/null
+++ b/Easy/How Many Numbers Are Smaller Than the Current Number.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int[] smallerNumbersThanCurrent(int[] nums) {
+    int[] counter = new int[101];
+    for (int num : nums) {
+      counter[num]++;
+    }
+    int sum = 0;
+    int[] preSum = new int[101];
+    for (int i = 0; i < 101; i++) {
+      preSum[i] = sum;
+      sum += counter[i];
+    }
+    int[] ans = new int[nums.length];
+    for (int i = 0; i < nums.length; i++) {
+      ans[i] = preSum[nums[i]];
+    }
+    return ans;
+  }
+}
diff --git a/Easy/Third Maximum Number.java b/Easy/Third Maximum Number.java
index f4cced58..7fcce2df 100644
--- a/Easy/Third Maximum Number.java	
+++ b/Easy/Third Maximum Number.java	
@@ -1,17 +1,23 @@
-public class Solution {
-    public int thirdMax(int[] nums) {
-        Arrays.sort(nums);
-        ArrayList<Integer> arr = new ArrayList();
-        for (int i=0;i<nums.length;i++) {
-            if (arr.indexOf(nums[i]) == -1) {
-                arr.add(nums[i]);
-            }
-        }
-        if (arr.size() >= 3) {
-            return arr.get(arr.size()-3);
-        }
-        else {
-            return arr.get(arr.size()-1);
-        }
+class Solution {  
+  public int thirdMax(int[] nums) {
+    final double BASE_VALUE = ((double) Integer.MIN_VALUE) - 1;
+    double firstMax = BASE_VALUE;
+    double secMax = BASE_VALUE;
+    double thirdMax = BASE_VALUE;
+    for (int num : nums) {
+      if (num > firstMax) {
+        thirdMax = secMax;
+        secMax = firstMax;
+        firstMax = num;
+      }
+      else if (num > secMax && num < firstMax) {
+        thirdMax = secMax;
+        secMax = num;
+      }
+      else if (num > thirdMax && num < firstMax && num < secMax) {
+        thirdMax = num;
+      }
     }
-}
\ No newline at end of file
+    return thirdMax == BASE_VALUE ? (int) firstMax : (int) thirdMax;
+  }
+}
diff --git a/Medium/Linked List in Binary Tree.java b/Medium/Linked List in Binary Tree.java
new file mode 100644
index 00000000..065a25c3
--- /dev/null
+++ b/Medium/Linked List in Binary Tree.java	
@@ -0,0 +1,42 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  public boolean isSubPath(ListNode head, TreeNode root) {
+    if (root == null) {
+      return false;
+    }
+    return (
+      helper(head, root) ||
+      isSubPath(head, root.left) ||
+      isSubPath(head, root.right)
+    );
+  } 
+  
+  private boolean helper(ListNode head, TreeNode root) {
+    if (head == null) {
+      return true;
+    }
+    if (head != null && root == null) {
+      return false;
+    }
+    if (head.val != root.val) {
+      return false;
+    }
+    return helper(head.next, root.left) || helper(head.next, root.right);
+  }
+}

From d174258f50fcd7c4c1b98cd6adc7d97aa9da994d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 2 Mar 2020 08:26:50 -0800
Subject: [PATCH 0116/2175] Added Long Pressed Name.java

---
 Easy/Long Pressed Name.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Long Pressed Name.java

diff --git a/Easy/Long Pressed Name.java b/Easy/Long Pressed Name.java
new file mode 100644
index 00000000..48f9e787
--- /dev/null
+++ b/Easy/Long Pressed Name.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public boolean isLongPressedName(String name, String typed) {
+    int nameIdx = 0;
+    int typeIdx = 0;
+    int nameLen = name.length();
+    int typeLen = typed.length();
+    while (nameIdx < nameLen && typeIdx < typeLen) {
+      if (name.charAt(nameIdx) != typed.charAt(typeIdx)) {
+        return false;
+      }
+      while (nameIdx < nameLen && typeIdx < typeLen && name.charAt(nameIdx) == typed.charAt(typeIdx)) {
+        nameIdx++;
+        typeIdx++;
+      }
+      char prev = name.charAt(nameIdx - 1);
+      while (typeIdx < typeLen && typed.charAt(typeIdx) == prev) {
+        typeIdx++;
+      }
+    }
+    return nameIdx == nameLen && typeIdx == typeLen;
+  }
+}

From 0eedd07e38882ae4a19c280d3690cb2d23c077be Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 3 Mar 2020 15:22:18 -0800
Subject: [PATCH 0117/2175] Added 2 solutions & modified 1 solution

---
 Medium/Campus Bikes.java              | 46 +++++++++++++++++
 Medium/Count Complete Tree Nodes.java | 73 +++++++++++++++++----------
 Medium/Path with Maximum Gold.java    | 30 +++++++++++
 3 files changed, 123 insertions(+), 26 deletions(-)
 create mode 100644 Medium/Campus Bikes.java
 create mode 100644 Medium/Path with Maximum Gold.java

diff --git a/Medium/Campus Bikes.java b/Medium/Campus Bikes.java
new file mode 100644
index 00000000..9d385afb
--- /dev/null
+++ b/Medium/Campus Bikes.java	
@@ -0,0 +1,46 @@
+class Solution {
+  public int[] assignBikes(int[][] workers, int[][] bikes) {
+    PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>(){
+      public int compare(Node n1, Node n2) {
+        int c = n1.dist - n2.dist;
+        if (c != 0) {
+          return c;
+        }
+        c = n1.workIdx - n2.workIdx;
+        return c != 0 ? c : n1.cycleIdx - n2.cycleIdx;
+      }
+    });
+    for (int i = 0; i < workers.length; i++) {
+      for (int j = 0; j < bikes.length; j++) {
+        pq.add(new Node(getDist(workers[i], bikes[j]), i, j));
+      }
+    }
+    int[] ans = new int[workers.length];
+    boolean[] bikesTaken = new boolean[bikes.length];
+    Arrays.fill(ans, Integer.MIN_VALUE);
+    while (!pq.isEmpty()) {
+      Node node = pq.remove();
+      if (ans[node.workIdx] == Integer.MIN_VALUE && !bikesTaken[node.cycleIdx]) {
+        ans[node.workIdx] = node.cycleIdx;
+        bikesTaken[node.cycleIdx] = true;
+      }
+    }
+    return ans;
+  }
+  
+  private int getDist(int[] p1, int[] p2) {
+    return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
+  }
+}
+
+class Node {
+  int dist;
+  int workIdx;
+  int cycleIdx;
+  
+  public Node(int dist, int workIdx, int cycleIdx) {
+    this.dist = dist;
+    this.workIdx = workIdx;
+    this.cycleIdx = cycleIdx;
+  }
+}
diff --git a/Medium/Count Complete Tree Nodes.java b/Medium/Count Complete Tree Nodes.java
index 2ee43014..8c4bd90f 100644
--- a/Medium/Count Complete Tree Nodes.java	
+++ b/Medium/Count Complete Tree Nodes.java	
@@ -8,32 +8,53 @@
  * }
  */
 class Solution {
-    public int countNodes(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        
-        int leftHeight = getHeight(root, 0);
-        int rightHeight = getHeight(root, 1);
-        
-        if (leftHeight == rightHeight) {
-            return (2 << (leftHeight - 1)) - 1;
-        }
-        
-        return countNodes(root.left) + countNodes(root.right) + 1;
+  public int countNodes(TreeNode root) {
+    if (root == null) {
+      return 0;
     }
-    
-    private int getHeight(TreeNode root, int dir) {
-        if (root == null) {
-            return 0;
-        }
-        
-        int height = 1;
-        while (root != null) {
-            root = dir == 0 ? root.left : root.right;
-            height++;
-        }
-        
-        return height - 1;
+    int d = getDepth(root);
+    if (d == 0) {
+      return 1;
     }
+    int start = 0;
+    int end = (int) Math.pow(2, d) - 1;
+    int mid;
+    while (start <= end) {
+      mid = start + (end - start) / 2;
+      if (exists(mid, d, root)) {
+        start = mid + 1;
+      }
+      else {
+        end = mid - 1;
+      }
+    }
+    return (int) Math.pow(2, d) - 1 + start;
+  }
+  
+  private int getDepth(TreeNode node) {
+    int d = 0;
+    while (node.left != null) {
+      node = node.left;
+      d++;
+    }
+    return d;
+  }
+  
+  private boolean exists(int idx, int d, TreeNode root) {
+    int left = 0;
+    int right = (int) Math.pow(2, d) - 1;
+    int mid;
+    for(int i = 0; i < d; ++i) {
+      mid = left + (right - left) / 2;
+      if (idx <= mid) {
+        root = root.left;
+        right = mid;
+      }
+      else {
+        root = root.right;
+        left = mid + 1;
+      }
+    }
+    return root != null;
+  }
 }
diff --git a/Medium/Path with Maximum Gold.java b/Medium/Path with Maximum Gold.java
new file mode 100644
index 00000000..3869c0c4
--- /dev/null
+++ b/Medium/Path with Maximum Gold.java	
@@ -0,0 +1,30 @@
+class Solution {
+  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public int getMaximumGold(int[][] grid) {
+    int maxGold = 0;
+    int rows = grid.length;
+    int cols = grid[0].length;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        int currGold = getMaxGold(grid, i, j, rows, cols, new boolean[rows][cols]);
+        maxGold = Math.max(maxGold, currGold);
+      }
+    }
+    return maxGold;
+  }
+  
+  private int getMaxGold(int[][] grid, int x, int y, int rows, int cols, boolean[][] visited) {
+    if (x < 0 || x >= rows || y < 0 || y >= cols || visited[x][y] || grid[x][y] == 0) {
+      return 0;
+    }
+    int curr = 0;
+    visited[x][y] = true;
+    for (int[] dir : dirs) {
+      int newX = x + dir[0];
+      int newY = y + dir[1];
+      curr = Math.max(curr, getMaxGold(grid, newX, newY, rows, cols, visited));
+    }
+    visited[x][y] = false;
+    return grid[x][y] + curr;
+  }
+}

From 1ef5194f237841180558128b0f0edbcca7cd1c70 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 5 Mar 2020 07:09:09 -0800
Subject: [PATCH 0118/2175] Added 1 solution & modified 2 solutions

---
 Easy/Flipping an Image.java       | 43 +++++++++++++++++--------------
 Easy/Last Stone Weight.java       | 41 ++++++++++++-----------------
 Easy/Sort Array By Parity II.java | 16 ++++++++++++
 3 files changed, 57 insertions(+), 43 deletions(-)
 create mode 100644 Easy/Sort Array By Parity II.java

diff --git a/Easy/Flipping an Image.java b/Easy/Flipping an Image.java
index ffb6fb5a..540bff8e 100644
--- a/Easy/Flipping an Image.java	
+++ b/Easy/Flipping an Image.java	
@@ -1,22 +1,27 @@
 class Solution {
-	public int[][] flipAndInvertImage(int[][] A) {
-        int[][] ans = new int[A.length][A[0].length];
-        
-        for (int i=0; i<A.length; i++) {
-            List<Integer> temp = Arrays.stream(A[i]).
-            							boxed().
-            							collect(Collectors.toList());
-            
-            Collections.reverse(temp);
-            ans[i] = temp.stream().mapToInt(e -> e).toArray();
-        }
-        
-        for (int i=0;i<ans.length;i++) {
-        	for (int j=0;j<ans[i].length;j++) {
-        		ans[i][j] = ans[i][j] == 1 ? 0 : 1;
-        	}
-        }
-        
-        return ans;
+  public int[][] flipAndInvertImage(int[][] A) {
+    for (int[] arr : A) {
+      reverse(arr);
+      invert(arr);
     }
+    return A;
+  }
+  
+  private void reverse(int[] arr) {
+    int start = 0;
+    int end = arr.length - 1;
+    while (start < end) {
+      int temp = arr[start];
+      arr[start] = arr[end];
+      arr[end] = temp;
+      start++;
+      end--;
+    }
+  }
+  
+  private void invert(int[] arr) {
+    for (int i = 0; i < arr.length; i++) {
+      arr[i] = arr[i] ^ 1;
+    }
+  }
 }
diff --git a/Easy/Last Stone Weight.java b/Easy/Last Stone Weight.java
index 8fba7ba5..237236ac 100644
--- a/Easy/Last Stone Weight.java	
+++ b/Easy/Last Stone Weight.java	
@@ -1,27 +1,20 @@
 class Solution {
-    public int lastStoneWeight(int[] stones) {
-        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
-            @Override
-            public int compare(Integer o1, Integer o2) {
-                return o2.compareTo(o1);
-            }
-        });
-
-        for (int stone : stones) {
-            pq.add(stone);
-        }
-
-        while (pq.size() > 1) {
-            int stone1 = pq.poll();
-            int stone2 = pq.poll();
-
-            int resSize = Math.max(stone1, stone2) - Math.min(stone1, stone2);
-
-            if (resSize > 0) {
-                pq.add(resSize);
-            }
-        }
-
-        return pq.size() == 1 ? pq.poll() : 0;
+  public int lastStoneWeight(int[] stones) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
+      public int compare(Integer o1, Integer o2) {
+        return o2 - o1;
+      }
+    });
+    for (int stone : stones) {
+      pq.add(stone);
     }
+    while(pq.size() > 1) {
+      int y = pq.poll();
+      int x = pq.poll();
+      if (x != y) {
+        pq.add(y - x);
+      }
+    }
+    return pq.isEmpty() ? 0 : pq.poll();
+  }
 }
diff --git a/Easy/Sort Array By Parity II.java b/Easy/Sort Array By Parity II.java
new file mode 100644
index 00000000..c03d9709
--- /dev/null
+++ b/Easy/Sort Array By Parity II.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int[] sortArrayByParityII(int[] A) {
+    int start = 1;
+    for (int i = 0; i < A.length; i += 2) {
+      if (A[i] % 2 == 1) {
+        while (A[start] % 2 != 0) {
+          start += 2;
+        }
+        int temp = A[i];
+        A[i] = A[start];
+        A[start] = temp;
+      }
+    }
+    return A;
+  }
+}

From c32df4556e47c836fdaa8302a1ac489478162f57 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 6 Mar 2020 15:28:05 -0800
Subject: [PATCH 0119/2175] Modified 2 solutions

---
 ...strings with Only One Distinct Letter.java | 29 +++++++++--------
 Medium/Complex Number Multiplication.java     | 32 ++++++++++---------
 2 files changed, 33 insertions(+), 28 deletions(-)

diff --git a/Easy/Count Substrings with Only One Distinct Letter.java b/Easy/Count Substrings with Only One Distinct Letter.java
index 4ef2a20f..acb84e7e 100644
--- a/Easy/Count Substrings with Only One Distinct Letter.java	
+++ b/Easy/Count Substrings with Only One Distinct Letter.java	
@@ -1,16 +1,19 @@
 class Solution {
-    public int countLetters(String S) {
-        int count = 0;
-        int result = 1;
-        for (int i = 1; i < S.length(); i++) {
-            if (S.charAt(i) == S.charAt(i- 1)) {
-                result++;
-            }
-            else {
-                count += (result * (result + 1)) / 2;
-                result = 1;
-            }
-        }
-        return count + (result * (result + 1)) / 2;
+  public int countLetters(String S) {
+    int start = 0;
+    int end = 0;
+    Map<Character, Integer> map = new HashMap<>();
+    int count = 0;
+    int n = S.length();
+    while (end < n) {
+      char c = S.charAt(end);
+      while (end < n && S.charAt(end) == c) {
+        end++;
+      }
+      int temp = end - start;
+      start = end;
+      count += temp * (temp + 1) / 2;
     }
+    return count;
+  }
 }
diff --git a/Medium/Complex Number Multiplication.java b/Medium/Complex Number Multiplication.java
index 61731cb1..c206de72 100644
--- a/Medium/Complex Number Multiplication.java	
+++ b/Medium/Complex Number Multiplication.java	
@@ -1,17 +1,19 @@
 class Solution {
-    public String complexNumberMultiply(String a, String b) {
-        String[] strA = a.trim().split("\\+");
-        String[] strB = b.trim().split("\\+");
-        
-        int realA = Integer.parseInt(strA[0]);
-        int realB = Integer.parseInt(strB[0]);
-        
-        int compA = Integer.parseInt(strA[1].substring(0,strA[1].length()-1));
-        int compB = Integer.parseInt(strB[1].substring(0,strB[1].length()-1));
-        
-        int realAns = (realA*realB) - (compA*compB);
-        int compAns = (realA*compB) + (realB*compA);
-        
-        return String.valueOf(realAns) + "+" + String.valueOf(compAns) + "i";
-    }
+  public String complexNumberMultiply(String a, String b) {
+    int realPart = 0;
+    int complexPart = 0;
+    int[] splitA = helper(a);
+    int[] splitB = helper(b);
+    realPart = splitA[0] * splitB[0] - splitA[1] * splitB[1];
+    complexPart = splitA[0] * splitB[1] + splitA[1] * splitB[0];
+    return realPart + "+" + complexPart + "i";
+  }
+  
+  private int[] helper(String s) {
+    String[] strs = s.split("\\+");
+    int[] arr = new int[2];
+    arr[0] = Integer.parseInt(strs[0]);
+    arr[1] = Integer.parseInt(strs[1].substring(0, strs[1].indexOf('i')));
+    return arr;
+  }
 }

From fdc1655174694fce43d2b27e23c17101e299c13c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 8 Mar 2020 09:19:56 -0700
Subject: [PATCH 0120/2175] Added 1 solution & modified 2 solutions

---
 Easy/Confusing Number.java             | 39 +++++++++++---------------
 Easy/Find the difference.java          | 36 +++++++++---------------
 Easy/Increasing Decreasing String.java | 32 +++++++++++++++++++++
 3 files changed, 62 insertions(+), 45 deletions(-)
 create mode 100644 Easy/Increasing Decreasing String.java

diff --git a/Easy/Confusing Number.java b/Easy/Confusing Number.java
index 288ad306..0f053ecb 100644
--- a/Easy/Confusing Number.java	
+++ b/Easy/Confusing Number.java	
@@ -1,25 +1,20 @@
 class Solution {
-    public boolean confusingNumber(int N) {
-        if (N == 0) {
-            return false;
-        }
-        int copy = N;
-        StringBuilder sb = new StringBuilder();
-        while (N > 0) {
-            int temp = N % 10;
-            if (temp == 6 || temp == 9) {
-                sb.append(temp == 6 ? 9 : 6); 
-            }
-            else if (temp == 0 || temp == 1 || temp == 8) {
-                sb.append(temp);
-            }
-            else {
-                return false;
-            }
-            
-            N /= 10;
-        }
-        
-        return Integer.parseInt(sb.toString()) != copy;
+  public boolean confusingNumber(int N) {
+    int newNum = 0;
+    int copy = N;
+    while (N > 0) {
+      int rem = N % 10;
+      N /= 10;
+      if (rem == 0 || rem == 1 || rem == 8) {
+        newNum = newNum * 10 + rem;
+      }
+      else if (rem == 6 || rem == 9) {
+        newNum = newNum * 10 + (rem == 6 ? 9 : 6);
+      }
+      else {
+        return false;
+      }
     }
+    return newNum != copy;
+  }
 }
diff --git a/Easy/Find the difference.java b/Easy/Find the difference.java
index cef03549..710a70d3 100644
--- a/Easy/Find the difference.java	
+++ b/Easy/Find the difference.java	
@@ -1,25 +1,15 @@
-public class Solution {
-    public char findTheDifference(String s, String t) {
-        String s1 = s;
-        String s2 = t;
-        s1 = sortString(s1);
-        s2 = sortString(s2);
-
-        char ans = '0';
-
-        for (int i=0;i< s1.length();i++) {
-            if (s2.charAt(i) != s1.charAt(i)) {
-                ans = s2.charAt(i);
-                break;
-            }
-        }
-        return ans == '0' ? s2.charAt(s2.length()-1) : ans;
+class Solution {
+  public char findTheDifference(String s, String t) {
+    int[] counter = new int[26];
+    for (char c : s.toCharArray()) {
+      counter[c - 'a']++;
     }
-    
-    public String sortString(String s) {
-        char[] chars = s.toCharArray();
-        Arrays.sort(chars);
-        String sorted = new String(chars);
-        return sorted;
+    for (char c : t.toCharArray()) {
+      if (counter[c - 'a'] == 0) {
+        return c;
+      }
+      counter[c - 'a']--;
     }
-}
\ No newline at end of file
+    return '-';
+  }
+}
diff --git a/Easy/Increasing Decreasing String.java b/Easy/Increasing Decreasing String.java
new file mode 100644
index 00000000..9aa71d09
--- /dev/null
+++ b/Easy/Increasing Decreasing String.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public String sortString(String s) {
+    int[] counter = new int[26];
+    for (char c : s.toCharArray()) {
+      counter[c - 'a']++;
+    }
+    StringBuilder sb = new StringBuilder();
+    while (sb.length() != s.length()) {
+      addLowerToHiger(sb, counter);
+      addHigherToLower(sb, counter);
+    }
+    return sb.toString();
+  }
+  
+  private void addLowerToHiger(StringBuilder sb, int[] counter) {
+    for (int i = 0; i < 26; i++) {
+      if (counter[i] != 0) {
+        sb.append((char) (97 + i));
+        counter[i]--;
+      }
+    }
+  }
+  
+  private void addHigherToLower(StringBuilder sb, int[] counter) {
+    for (int i = 25; i >= 0; i--) {
+      if (counter[i] != 0) {
+        sb.append((char) (97 + i));
+        counter[i]--;
+      }
+    }
+  }
+}

From 474b651555af66220dc6da10229abcbd186da270 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 9 Mar 2020 16:34:44 -0700
Subject: [PATCH 0121/2175] Added 2 solutions

---
 Easy/Next Greater Element I.java              | 20 +++++++++++
 .../Longest ZigZag Path in a Binary Tree.java | 36 +++++++++++++++++++
 2 files changed, 56 insertions(+)
 create mode 100644 Easy/Next Greater Element I.java
 create mode 100644 Medium/Longest ZigZag Path in a Binary Tree.java

diff --git a/Easy/Next Greater Element I.java b/Easy/Next Greater Element I.java
new file mode 100644
index 00000000..8b7e88d1
--- /dev/null
+++ b/Easy/Next Greater Element I.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int[] nextGreaterElement(int[] nums1, int[] nums2) {
+    Stack<Integer> stack = new Stack<>();
+    int[] greater = new int[nums2.length];
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = nums2.length - 1; i >= 0; i--) {
+      while (!stack.isEmpty() && stack.peek() < nums2[i]) {
+        stack.pop();
+      }
+      greater[i] = stack.isEmpty() ? -1 : stack.peek();
+      map.put(nums2[i], i);
+      stack.push(nums2[i]);
+    }
+    int[] ans = new int[nums1.length];
+    for (int i = 0; i < nums1.length; i++) {
+      ans[i] = greater[map.get(nums1[i])];
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Longest ZigZag Path in a Binary Tree.java b/Medium/Longest ZigZag Path in a Binary Tree.java
new file mode 100644
index 00000000..bdc3e8f9
--- /dev/null
+++ b/Medium/Longest ZigZag Path in a Binary Tree.java	
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  int max;
+  public int longestZigZag(TreeNode root) {
+    if (root == null) {
+      return -1;
+    }
+    max = 0;
+    helper(root.right, 1, true);
+    helper(root.left, 1, false);
+    return max;
+  } 
+  
+  private void helper(TreeNode root, int step, boolean isRight) {
+    if (root == null) {
+      return;
+    }
+    max = Math.max(max, step);
+    if (isRight) {
+      helper(root.left, step + 1, false);
+      helper(root.right, 1, true);
+    }
+    else {
+      helper(root.right, step + 1, true);
+      helper(root.left, 1, false);
+    }
+  }
+}

From f8b88f15e0a7962e8d8f266f7ead92e343d16a8b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 10 Mar 2020 08:47:47 -0700
Subject: [PATCH 0122/2175] Added 2 solutions & modified 1 solution

---
 ... With Characters That Have Odd Counts.java | 17 ++++
 Easy/Maximum Average Subarray I.java          | 17 ++++
 Medium/Longest Absolute File Path.java        | 80 ++++++++-----------
 3 files changed, 66 insertions(+), 48 deletions(-)
 create mode 100644 Easy/Generate a String With Characters That Have Odd Counts.java
 create mode 100644 Easy/Maximum Average Subarray I.java

diff --git a/Easy/Generate a String With Characters That Have Odd Counts.java b/Easy/Generate a String With Characters That Have Odd Counts.java
new file mode 100644
index 00000000..c820746c
--- /dev/null
+++ b/Easy/Generate a String With Characters That Have Odd Counts.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public String generateTheString(int n) {
+    StringBuilder sb = new StringBuilder();
+    if (n % 2 == 0) {
+      sb.append('a');
+      for (int i = 0; i < n - 1; i++) {
+        sb.append('b');
+      }
+    }
+    else {
+      for (int i = 0; i < n; i++) {
+        sb.append('a');
+      }
+    }
+    return sb.toString();
+  }
+}
diff --git a/Easy/Maximum Average Subarray I.java b/Easy/Maximum Average Subarray I.java
new file mode 100644
index 00000000..7ac37a5c
--- /dev/null
+++ b/Easy/Maximum Average Subarray I.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public double findMaxAverage(int[] nums, int k) {
+    Double max = null;
+    double sum = 0;
+    for (int i = 0; i < k - 1; i++) {
+      sum += nums[i];
+    }
+    int start = 0;
+    for (int i = k - 1; i < nums.length; i++) {
+      sum += nums[i];
+      double avg = sum / k;
+      max = max == null ? avg : Math.max(max, avg);
+      sum -= nums[start++];
+    }
+    return max;
+  }
+}
diff --git a/Medium/Longest Absolute File Path.java b/Medium/Longest Absolute File Path.java
index e23f6115..8dc2426d 100644
--- a/Medium/Longest Absolute File Path.java	
+++ b/Medium/Longest Absolute File Path.java	
@@ -1,52 +1,36 @@
 class Solution {
-    public int lengthLongestPath(String input) {
-        int maxLen = 0;
-        
-        // Variables for each iteration
-        int currLevel = 1;
-        boolean isFile = false;
-        int currLen = 0;
-        
-        // HashMap to store length for each level
-        Map<Integer, Integer> map = new HashMap<>();
-        
-        // Base entry for 0th level
-        map.put(0, 0);
-        
-        int idx = 0;
-        int n = input.length();
-        while (idx < n) {
-            // Keep increasing the level until we find a tab
-            while (idx < n && input.charAt(idx) == '\t') {
-                idx++;
-                currLevel++;
-            }
-            
-            // Keep increasing currLen for the characters in the name
-            while (idx < n && input.charAt(idx) != '\n') {
-                if (input.charAt(idx) == '.') {
-                    isFile = true;
-                }
-                
-                currLen++;
-                idx++;
-            }
-            
-            // If isFile then update maxLen else update the value of level in map
-            if (isFile) {
-                maxLen = Math.max(maxLen, map.get(currLevel - 1) + currLen);
-            }
-            else {
-                map.put(currLevel, map.get(currLevel - 1) + 1 + currLen);
-            }
-            
-            // Reset variables
-            currLen = 0;
-            currLevel = 1;
-            isFile = false;
-            idx++;
+  public int lengthLongestPath(String input) {
+    int maxLen = 0;
+    int currLevel = 1;
+    boolean isFile = false;
+    int currLen = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    map.put(0, 0);
+    int idx = 0;
+    int n = input.length();
+    while (idx < n) {
+      while (idx < n && input.charAt(idx) == '\t') {
+        idx++;
+        currLevel++;
+      }
+      while (idx < n && input.charAt(idx) != '\n') {
+        if (input.charAt(idx) == '.') {
+          isFile = true;
         }
-        
-        return maxLen;
+        currLen++;
+        idx++;
+      }
+      if (isFile) {
+        maxLen = Math.max(maxLen, map.get(currLevel - 1) + currLen);
+      }
+      else {
+        map.put(currLevel, map.get(currLevel - 1) + 1 + currLen);
+      }
+      currLen = 0;
+      currLevel = 1;
+      isFile = false;
+      idx++;
     }
+    return maxLen;
+  }
 }

From 1328cbf181332621426310c091ea086b31a88c7d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 12 Mar 2020 11:19:34 -0700
Subject: [PATCH 0123/2175] Added 1 solution & modified 2 solutions

---
 Easy/Find Common Characters.java      | 21 +++++++++
 Easy/Minimum Absolute Difference.java | 29 ++++++------
 Easy/Relative Sort Array.java         | 67 ++++++++++++---------------
 3 files changed, 66 insertions(+), 51 deletions(-)
 create mode 100644 Easy/Find Common Characters.java

diff --git a/Easy/Find Common Characters.java b/Easy/Find Common Characters.java
new file mode 100644
index 00000000..e813b42e
--- /dev/null
+++ b/Easy/Find Common Characters.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public List<String> commonChars(String[] A) {
+    int[][] counter = new int[A.length][26];
+    for (int i = 0; i < A.length; i++) {
+      for (char c : A[i].toCharArray()) {
+        counter[i][c - 'a']++;
+      }
+    }
+    List<String> list = new ArrayList<>();
+    for (int i = 0; i < 26; i++) {
+      int minCount = Integer.MAX_VALUE;
+      for (int j = 0; j < counter.length; j++) {
+        minCount = Math.min(minCount, counter[j][i]);
+      }
+      while (minCount-- > 0) {
+        list.add(String.valueOf((char) (97 + i)));
+      }
+    }
+    return list;
+  }
+}
diff --git a/Easy/Minimum Absolute Difference.java b/Easy/Minimum Absolute Difference.java
index 48ff75e9..c7204166 100644
--- a/Easy/Minimum Absolute Difference.java	
+++ b/Easy/Minimum Absolute Difference.java	
@@ -1,16 +1,19 @@
 class Solution {
-    public List<List<Integer>> minimumAbsDifference(int[] arr) {
-        Arrays.sort(arr);
-        int minDiff = arr[1] - arr[0];
-        for (int i = 2; i < arr.length; i++) {
-            minDiff = Math.min(minDiff, arr[i] - arr[i - 1]);
-        }
-        List<List<Integer>> ans = new ArrayList<>();
-        for (int i = 1; i < arr.length; i++) {
-            if (arr[i] - arr[i - 1] == minDiff) {
-                ans.add(Arrays.asList(arr[i - 1], arr[i]));
-            } 
-        }
-        return ans;
+  public List<List<Integer>> minimumAbsDifference(int[] arr) {
+    List<List<Integer>> list = new ArrayList<>();
+    int minDiff = Integer.MAX_VALUE;
+    Arrays.sort(arr);
+    for (int i = 0; i < arr.length - 1; i++) {
+      int diff = arr[i + 1] - arr[i];
+      if (diff < minDiff) {
+        list.clear();
+        list.add(Arrays.asList(arr[i], arr[i + 1]));
+        minDiff = diff;
+      }
+      else if (diff == minDiff) {
+        list.add(Arrays.asList(arr[i], arr[i + 1]));
+      }
     }
+    return list;
+  }
 }
diff --git a/Easy/Relative Sort Array.java b/Easy/Relative Sort Array.java
index 00869ab1..886b0c71 100644
--- a/Easy/Relative Sort Array.java	
+++ b/Easy/Relative Sort Array.java	
@@ -1,41 +1,32 @@
 class Solution {
-    public int[] relativeSortArray(int[] A1, int[] A2) {
-        Map<Integer, Integer> a2Map = new LinkedHashMap<>();
-        Map<Integer, Integer> a1Map = new HashMap<>();
-        int idx = 0;
-        for (int num : A2) {
-            if (!a2Map.containsKey(num)) {
-                a2Map.put(num, idx++);
-            }
-        }
-
-        for (int num : A1) {
-            a1Map.put(num, a1Map.getOrDefault(num, 0) + 1);
-        }
-
-        int i = 0;
-        for (Integer key : a2Map.keySet()) {
-            int count = a1Map.getOrDefault(key, 0);
-            while (count-- > 0) {
-                A1[i++] = key;
-            }
-            
-            a1Map.remove(key);
-        }
-
-        List<Integer> leftOver = new ArrayList<>();
-        for (Integer key : a1Map.keySet()) {
-            int count = a1Map.get(key);
-            while (count-- > 0) {
-                leftOver.add(key);
-            }
-        }
-
-        Collections.sort(leftOver);
-        for (int num : leftOver) {
-            A1[i++] = num;
-        }
-        
-        return A1;
+  public int[] relativeSortArray(int[] arr1, int[] arr2) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < arr2.length; i++) {
+      map.put(arr2[i], i);
     }
+    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
+      public int compare(Integer o1, Integer o2) {
+        return map.get(o1) - map.get(o2);
+      }
+    });
+    List<Integer> notPresent = new ArrayList<>();
+    for (int num : arr1) {
+      if (map.containsKey(num)) {
+        pq.add(num);
+      }
+      else {
+        notPresent.add(num);
+      }
+    }
+    int[] ans = new int[arr1.length];
+    int idx = 0;
+    while (!pq.isEmpty()) {
+      ans[idx++] = pq.poll();
+    }
+    Collections.sort(notPresent);
+    for (int num : notPresent) {
+      ans[idx++] = num;
+    }
+    return ans;
+  }
 }

From 68f48a357a7463cb559751ede4333a6e8259c8aa Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 13 Mar 2020 07:24:17 -0700
Subject: [PATCH 0124/2175] Modified 2 solutions

---
 Easy/Available Captures for Rook.java       | 107 +++++---------------
 Easy/Sum of Even Numbers After Queries.java |  43 ++++----
 2 files changed, 45 insertions(+), 105 deletions(-)

diff --git a/Easy/Available Captures for Rook.java b/Easy/Available Captures for Rook.java
index b994dcaa..52cea4ec 100644
--- a/Easy/Available Captures for Rook.java	
+++ b/Easy/Available Captures for Rook.java	
@@ -1,86 +1,33 @@
 class Solution {
-    public int numRookCaptures(char[][] board) {
-        int numOfPawns = 0;
-        
-        int[] rookPos = getRookPos(board);
-        int row = rookPos[0];
-        int col = rookPos[1];
-        
-        for (int i = col + 1; i < board[0].length; i++) {
-            if (board[row][i] == '.') {
-                continue;
-            }
-            
-            if (board[row][i] == 'B') {
-                break;
-            }
-            
-            if (board[row][i] == 'p') {
-                numOfPawns++;
-                break;
-            }
+  int[][] dirs = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
+  public int numRookCaptures(char[][] board) {
+    for (int i = 0; i < board.length; i++) {
+      for (int j = 0; j < board[i].length; j++) {
+        if (board[i][j] == 'R') {
+          return getPawnCount(board, i, j);
         }
-        
-        for (int i = col - 1; i >= 0; i--) {
-            if (board[row][i] == '.') {
-                continue;
-            }
-            
-            if (board[row][i] == 'B') {
-                break;
-            }
-            
-            if (board[row][i] == 'p') {
-                numOfPawns++;
-                break;
-            }
-        }
-        
-        for (int i = row + 1; i < board.length; i++) {
-            if (board[i][col] == '.') {
-                continue;
-            }
-            
-            if (board[i][col] == 'B') {
-                break;
-            }
-            
-            if (board[i][col] == 'p') {
-                numOfPawns++;
-                break;
-            }
-        }
-        
-        for (int i = row - 1; i >= 0; i--) {
-            if (board[i][col] == '.') {
-                continue;
-            }
-            
-            if (board[i][col] == 'B') {
-                break;
-            }
-            
-            if (board[i][col] == 'p') {
-                numOfPawns++;
-                break;
-            }
-        }
-        
-        return numOfPawns;
+      }
     }
-    
-    private int[] getRookPos(char[][] board) {
-        int[] pos = new int[2];
-        
-        for (int i = 0; i < board.length; i++) {
-            for (int j = 0; j < board[i].length; j++) {
-                if (board[i][j] == 'R') {
-                    pos[0] = i;
-                    pos[1] = j;
-                }
-            }
+    return 0;
+  }
+  
+  private int getPawnCount(char[][] board, int i, int j) {
+    int count = 0;
+    for (int[] dir : dirs) {
+      int newX = i + dir[0];
+      int newY = j + dir[1];
+      while (newX >= 0 && newX < board.length && newY >= 0 && newY < board[0].length) {
+        if (board[newX][newY] == 'p') {
+          count++;
+          break;
+        }
+        else if (board[newX][newY] == 'B') {
+          break;
         }
-        
-        return pos;
+        newX = newX + dir[0];
+        newY = newY + dir[1];
+      }
     }
+    return count;
+  }
 }
diff --git a/Easy/Sum of Even Numbers After Queries.java b/Easy/Sum of Even Numbers After Queries.java
index a7e1e9f8..8b7d1d27 100644
--- a/Easy/Sum of Even Numbers After Queries.java	
+++ b/Easy/Sum of Even Numbers After Queries.java	
@@ -1,28 +1,21 @@
 class Solution {
-    public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
-        int[] evenQuerySum = new int[queries.length];
-        
-        int currEvenSum = 0;
-        for (int num : A) {
-            currEvenSum += num % 2 == 0 ? num : 0;
-        }
-        
-        for (int i=0; i<queries.length; i++) {
-            int val = queries[i][0];
-            int idx = queries[i][1];
-            boolean wasPrevEven = A[idx] % 2 == 0;
-            A[idx] = A[idx] + val;
-            
-            if (A[idx] % 2 == 0) {
-                currEvenSum += wasPrevEven ? val : A[idx];
-            }
-            else {
-                currEvenSum -= wasPrevEven ? (A[idx] - val) : 0;
-            }
-            
-            evenQuerySum[i] = currEvenSum;
-        }
-        
-        return evenQuerySum;
+  public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
+    int sum = 0;
+    for (int num : A) {
+      sum += num % 2 == 0 ? num : 0;
     }
+    int[] ans = new int[queries.length];
+    for (int i = 0; i < queries.length; i++) {
+      int newVal = A[queries[i][1]] + queries[i][0];
+      if (A[queries[i][1]] % 2 == 0) {
+        sum -= A[queries[i][1]];
+      }
+      A[queries[i][1]] = newVal;
+      if (A[queries[i][1]] % 2 == 0) {
+        sum += newVal;
+      }
+      ans[i] = sum;
+    }
+    return ans;
+  }
 }

From 5127a5a3adef7ef4d05e59bd2ce63df4b979ccb0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 17 Mar 2020 12:31:26 -0700
Subject: [PATCH 0125/2175] Added Design a Stack With Increment Operation.java

---
 ...sign a Stack With Increment Operation.java | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 Medium/Design a Stack With Increment Operation.java

diff --git a/Medium/Design a Stack With Increment Operation.java b/Medium/Design a Stack With Increment Operation.java
new file mode 100644
index 00000000..34f80a99
--- /dev/null
+++ b/Medium/Design a Stack With Increment Operation.java	
@@ -0,0 +1,44 @@
+class CustomStack {
+  Stack<Integer> stack;
+  int maxSize;
+  int[] increment;
+  public CustomStack(int maxSize) {
+    this.maxSize = maxSize;
+    stack = new Stack<>();
+    increment = new int[maxSize];
+  }
+
+  public void push(int x) {
+    if (stack.size() < maxSize) {
+      stack.push(x);
+    }
+  }
+
+  public int pop() {
+    int idx = stack.size() - 1;
+    if (idx < 0) {
+      return -1;
+    }
+    if (idx > 0) {
+      increment[idx - 1] += increment[idx];
+    }
+    int ans = stack.pop() + increment[idx];
+    increment[idx] = 0;
+    return ans;
+  }
+
+  public void increment(int k, int val) {
+    int idx = Math.min(k, stack.size()) - 1;
+    if (idx >= 0) {
+      increment[idx] += val;
+    }
+  }
+}
+
+/**
+ * Your CustomStack object will be instantiated and called as such:
+ * CustomStack obj = new CustomStack(maxSize);
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * obj.increment(k,val);
+ */

From 28760f5f96eb348a2eeaa319a68e7d672a2e50ac Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 18 Mar 2020 17:23:24 -0700
Subject: [PATCH 0126/2175] Modified 3 solutions

---
 Easy/First Unique Character in a String.java |  19 +++
 Easy/first_unique_character_in_a_string.java |  21 ---
 Hard/Design Search Autocomplete System.java  | 168 ++++++++-----------
 Medium/Search in Rotated Sorted Array.java   |  53 +++---
 4 files changed, 118 insertions(+), 143 deletions(-)
 create mode 100644 Easy/First Unique Character in a String.java
 delete mode 100644 Easy/first_unique_character_in_a_string.java

diff --git a/Easy/First Unique Character in a String.java b/Easy/First Unique Character in a String.java
new file mode 100644
index 00000000..64bacbda
--- /dev/null
+++ b/Easy/First Unique Character in a String.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int firstUniqChar(String s) {
+    int[] arr = new int[26];
+    for (char c : s.toCharArray()) {
+      if (arr[c - 'a'] != 0) {
+        arr[c - 'a'] = -1;
+      }
+      else {
+        arr[c - 'a'] = 1;
+      }
+    }
+    for (int i = 0; i < s.length(); i++) {
+      if (arr[s.charAt(i) - 'a'] == 1) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}
diff --git a/Easy/first_unique_character_in_a_string.java b/Easy/first_unique_character_in_a_string.java
deleted file mode 100644
index bb140a7f..00000000
--- a/Easy/first_unique_character_in_a_string.java
+++ /dev/null
@@ -1,21 +0,0 @@
-public class Solution {
-    public int firstUniqChar(String s) {
-        int n = s.length();
-        StringBuilder sb=new StringBuilder("");
-        for(int i=0;i<n;i++){
-            if (sb.toString().indexOf(s.charAt(i)) == -1) {
-                sb.append(String.valueOf(s.charAt(i)));
-            }
-        }
-        
-        int m = sb.toString().length();
-        String sb_s = sb.toString();
-        
-        for(int i=0;i<m;i++) {
-            if (n - s.replace(String.valueOf(sb_s.charAt(i)),"").length() == 1) {
-                return s.indexOf(sb_s.charAt(i));
-            }
-        }
-        return -1;
-    }
-}
\ No newline at end of file
diff --git a/Hard/Design Search Autocomplete System.java b/Hard/Design Search Autocomplete System.java
index 161bf92e..98888b69 100644
--- a/Hard/Design Search Autocomplete System.java	
+++ b/Hard/Design Search Autocomplete System.java	
@@ -1,107 +1,87 @@
 class AutocompleteSystem {
-
-    Node root;
-    Map<String, Integer> wordWeight;
-    int i;
-    StringBuilder sb;
-
-    public AutocompleteSystem(String[] sentences, int[] times) {
-        root = new Node("");
-        wordWeight = new HashMap<>();
-        i = 0;
-        sb = new StringBuilder();
-
-        for (String sentence : sentences) {
-            insertWord(sentence);
-            wordWeight.put(sentence, times[i++]);
-        }
+  Map<String, Integer> map;
+  Node root;
+  Node currNode;
+  StringBuilder sb;
+  boolean invalidQuery;
+  public AutocompleteSystem(String[] sentences, int[] times) {
+    map = new HashMap<>();
+    root = new Node('-');
+    for (int i = 0; i < sentences.length; i++) {
+      addSentence(sentences[i], 0, root);
+      map.put(sentences[i], map.getOrDefault(sentences[i], 0) + times[i]);
     }
-
-    private void insertWord(String sentence) {
-        Node curr = root;
-        for (int i=0; i<sentence.length(); i++) {
-            if (!curr.childrens.containsKey(sentence.charAt(i))) {
-                curr.childrens.put(sentence.charAt(i), new Node(sentence.substring(0, i+1)));
-            }
-
-            curr = curr.childrens.get(sentence.charAt(i));
-
-            if (i == sentence.length()-1) {
-                curr.isWord = true;
-            }
-        }
+    currNode = root;
+    invalidQuery = false;
+    sb = new StringBuilder();
+  }
+  
+  private void addSentence(String s, int idx, Node root) {
+    if (idx == s.length()) {
+      return;
     }
-
-    public List<String> input(char c) {
-        if (c == '#') {
-            wordWeight.put(sb.toString(), wordWeight.getOrDefault(sb.toString(), 0) + 1);
-            insertWord(sb.toString());
-            sb = new StringBuilder();
-            return new ArrayList<>();
-        }
-
-        sb.append(c);
-
-        PriorityQueue<String> pq = new PriorityQueue<>(new Comparator<String>() {
-            @Override
-            public int compare(String o1, String o2) {
-                if (wordWeight.get(o1) - wordWeight.get(o2) == 0) {
-                    return o2.compareTo(o1);
-                }
-                else {
-                    return wordWeight.get(o1) - wordWeight.get(o2);
-                }
-            }
-        });
-
-        String prefix = sb.toString();
-        Node curr = root;
-
-        for (char ch : prefix.toCharArray()) {
-            if (curr.childrens.containsKey(ch)) {
-                curr = curr.childrens.get(ch);
-            }
-            else {
-                return new ArrayList<>();
-            }
-        }
-
-        findAllChildWorlds(curr, pq);
-
-        List<String> ans = new ArrayList<>();
-        while (!pq.isEmpty()) {
-            ans.add(pq.poll());
-        }
-
-        Collections.reverse(ans);
-
-        return ans;
+    char c = s.charAt(idx);
+    if (!root.children.containsKey(c)) {
+      root.children.put(c, new Node(c));
     }
-
-    private void findAllChildWorlds(Node curr, PriorityQueue<String> pq) {
-        if (curr.isWord) {
-            pq.add(curr.prefix);
-            if (pq.size() > 3) {
-                pq.poll();
-            }
-        }
-
-        for (char c : curr.childrens.keySet()) {
-            findAllChildWorlds(curr.childrens.get(c), pq);
+    Node node = root.children.get(c);
+    node.possibleSentences.add(s);
+    addSentence(s, idx + 1, node);
+  }
+
+  public List<String> input(char c) {
+    if (c == '#') {
+      String s = sb.toString();
+      map.put(s, map.getOrDefault(s, 0) + 1);
+      addSentence(s, 0, root);
+      sb.setLength(0);
+      currNode = root;
+      invalidQuery = false;
+      return new ArrayList<>();
+    }
+    sb.append(c);
+    if (!currNode.children.containsKey(c) || invalidQuery) {
+      invalidQuery = true;
+      return new ArrayList<>();
+    }
+    else {
+      List<String> possibleSentences = new ArrayList<>();
+      currNode = currNode.children.get(c);
+      possibleSentences.addAll(currNode.possibleSentences);
+      return getTopThree(possibleSentences);
+    }
+  }
+  
+  private List<String> getTopThree(List<String> list) {
+    Collections.sort(list, new Comparator<String>(){
+      public int compare(String s1, String s2) {
+        int c = map.get(s2) - map.get(s1);
+        if (c != 0) {
+          return c;
         }
+        return s1.compareTo(s2);
+      }
+    });
+    List<String> ans = new ArrayList<>();
+    for (int i = 0; i < list.size() && ans.size() < 3; i++) {
+      ans.add(list.get(i));
     }
+    return ans;
+  }
 }
 
 class Node {
-    String prefix;
-    Map<Character, Node> childrens;
-    boolean isWord;
-
-    public Node(String prefix) {
-        this.prefix = prefix;
-        this.childrens = new HashMap<>();
-    }
+  char c;
+  Map<Character, Node> children;
+  Set<String> possibleSentences;
+  
+  public Node(char c) {
+    this.c = c;
+    children = new HashMap<>();
+    possibleSentences = new HashSet<>();
+  }
 }
+
 /**
  * Your AutocompleteSystem object will be instantiated and called as such:
  * AutocompleteSystem obj = new AutocompleteSystem(sentences, times);
diff --git a/Medium/Search in Rotated Sorted Array.java b/Medium/Search in Rotated Sorted Array.java
index e078af3f..43104bf9 100644
--- a/Medium/Search in Rotated Sorted Array.java	
+++ b/Medium/Search in Rotated Sorted Array.java	
@@ -1,32 +1,29 @@
 class Solution {
-    public int search(int[] nums, int target) {
-        int start = 0;
-        int end = nums.length - 1;
-
-        while (start <= end) {
-            int mid = (start + end)/2;
-            if (nums[mid] == target) {
-                return mid;
-            }
-            if (nums[start] <= nums[mid]){
-                if (target < nums[mid] && target >= nums[start]) {
-                    end = mid - 1;
-                }
-                else {
-                    start = mid + 1;
-                }
-            }
-
-            else if (nums[mid] <= nums[end]){
-                if (target > nums[mid] && target <= nums[end]) {
-                    start = mid + 1;
-                }
-                else {
-                    end = mid - 1;
-                }
-            }
+  public int search(int[] nums, int target) {
+    int start = 0;
+    int end = nums.length - 1;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (nums[mid] == target) {
+        return mid;
+      }
+      if (nums[mid] >= nums[start]) {
+        if (nums[start] <= target && nums[mid] > target) {
+            end = mid - 1;
         }
-
-        return -1;
+        else {
+            start = mid + 1;
+        }
+      }
+      else {
+        if (nums[end] >= target && nums[mid] < target) {
+            start = mid + 1;
+        }
+        else {
+            end = mid - 1;
+        }
+      }
     }
+    return -1;
+  }
 }

From 447d296c52fedaf8f670adcdc7ea07aa661a4745 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 18 Mar 2020 18:48:23 -0700
Subject: [PATCH 0127/2175] Added 132 Pattern.java

---
 Medium/132 Pattern.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/132 Pattern.java

diff --git a/Medium/132 Pattern.java b/Medium/132 Pattern.java
new file mode 100644
index 00000000..33d16450
--- /dev/null
+++ b/Medium/132 Pattern.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public boolean find132pattern(int[] nums) {
+    if (nums.length < 3) {
+      return false;
+    }
+    Stack<Integer> stack = new Stack<>();
+    int[] min = new int[nums.length];
+    min[0] = nums[0];
+    for (int i = 1; i < nums.length; i++) {
+      min[i] = Math.min(min[i - 1], nums[i]);
+    }
+    for (int i = nums.length - 1; i >= 0; i--) {
+      if (nums[i] > min[i]) {  // Consider nums[i] as 3 and min[i] as 1
+        while (!stack.isEmpty() && stack.peek() <= min[i]) {  // Search for 2  
+          stack.pop();
+        }
+        if (!stack.isEmpty() && stack.peek() < nums[i]) {  // If 2 found
+          return true;
+        }
+        stack.push(nums[i]);
+      }
+    }
+    return false;
+  }
+}

From 520ce8f3075d5ba88f1fc07fd091aa6ce3155335 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 19 Mar 2020 19:19:12 -0700
Subject: [PATCH 0128/2175] Modified Ransom Note.java

---
 Easy/Ransom Note.java | 46 +++++++++++++------------------------------
 1 file changed, 14 insertions(+), 32 deletions(-)

diff --git a/Easy/Ransom Note.java b/Easy/Ransom Note.java
index 9536cf51..f302bc31 100644
--- a/Easy/Ransom Note.java	
+++ b/Easy/Ransom Note.java	
@@ -1,35 +1,17 @@
 class Solution {
-    public boolean canConstruct(String ransomNote, String magazine) {
-        Map<Character, Integer> noteMap = new HashMap<>();
-        Map<Character, Integer> magMap = new HashMap<>();
-        
-        for(char c: ransomNote.toCharArray()) {
-            if (noteMap.containsKey(c)) {
-                noteMap.put(c, noteMap.get(c) + 1);
-            }
-            else {
-                noteMap.put(c, 1);
-            }
-        }
-        
-        for(char c: magazine.toCharArray()) {
-            if (magMap.containsKey(c)) {
-                magMap.put(c, magMap.get(c) + 1);
-            }
-            else {
-                magMap.put(c, 1);
-            }
-        }
-        
-        for (Map.Entry<Character, Integer> entry: noteMap.entrySet()) {
-            if (magMap.containsKey(entry.getKey()) && magMap.get(entry.getKey()) >= entry.getValue()) {
-                continue;
-            }
-            else {
-                return false;
-            }
-        }
-        
-        return true;
+  public boolean canConstruct(String ransomNote, String magazine) {
+    int[] counter = new int[26];
+    for (char c : ransomNote.toCharArray()) {
+      counter[c - 'a']++;
     }
+    for (char c : magazine.toCharArray()) {
+      counter[c - 'a']--;
+    }
+    for (int i = 0; i < 26; i++) {
+      if (counter[i] > 0) {
+        return false;
+      }
+    }
+    return true;
+  } 
 }

From b4201a217e950a87c1d14505c446bae425b92a46 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 21 Mar 2020 09:02:36 -0700
Subject: [PATCH 0129/2175] Added 1 solution & modified 3 solutions

---
 Easy/Roman to Integer.java                    | 61 +++++++------------
 Hard/Frog Jump.java                           | 26 ++++++++
 .../Maximum Size Subarray Sum Equals k.java   | 35 +++++------
 Medium/Next Greater Element II.java           | 40 ++++++------
 4 files changed, 82 insertions(+), 80 deletions(-)
 create mode 100644 Hard/Frog Jump.java

diff --git a/Easy/Roman to Integer.java b/Easy/Roman to Integer.java
index 42b44427..7b269b0b 100644
--- a/Easy/Roman to Integer.java	
+++ b/Easy/Roman to Integer.java	
@@ -1,42 +1,25 @@
 class Solution {
-    public int romanToInt(String s) {
-        int nums[] = new int[s.length()];
-        for(int i = 0; i < s.length(); i++) {
-            switch (s.charAt(i)){
-                case 'M':
-                    nums[i]=1000;
-                    break;
-                case 'D':
-                    nums[i]=500;
-                    break;
-                case 'C':
-                    nums[i]=100;
-                    break;
-                case 'L':
-                    nums[i]=50;
-                    break;
-                case 'X' :
-                    nums[i]=10;
-                    break;
-                case 'V':
-                    nums[i]=5;
-                    break;
-                case 'I':
-                    nums[i]=1;
-                    break;
-            }
-        }
-        
-        int sum = 0;
-        for(int i = 0; i < nums.length - 1; i++){
-            if(nums[i] < nums[i + 1]) {
-                sum -= nums[i];
-            }   
-            else {
-                sum += nums[i];
-            }
-        }
-        
-        return sum + nums[nums.length - 1];
+  public int romanToInt(String s) {
+    String[] keys = {"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"};
+    int[] values = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
+    Map<String, Integer> map = new HashMap<>();
+    for (int i = 0; i < keys.length; i++) {
+      map.put(keys[i], values[i]);
     }
+    int val = 0;
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      char c = s.charAt(idx);
+      if (idx + 1 < n && map.containsKey(s.substring(idx, idx + 2))) {
+        val += map.get(s.substring(idx, idx + 2));
+        idx += 2;
+      }
+      else {
+        val += map.get(String.valueOf(c));
+        idx++;
+      }
+    }
+    return val;
+  }
 }
diff --git a/Hard/Frog Jump.java b/Hard/Frog Jump.java
new file mode 100644
index 00000000..4885064e
--- /dev/null
+++ b/Hard/Frog Jump.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public boolean canCross(int[] stones) {
+    int[][] memo = new int[stones.length][stones.length];
+    for (int[] row : memo) {
+      Arrays.fill(row, -1);
+    }
+    return helper(stones, 0, 0, memo) == 1;
+  }
+  
+  private int helper(int[] stones, int idx, int jumpSize, int[][] memo) {
+    if (memo[idx][jumpSize] >= 0) {
+      return memo[idx][jumpSize];
+    }
+    for (int i = idx + 1; i < stones.length; i++) {
+      int gap = stones[i] - stones[idx];
+      if (gap >= jumpSize - 1 && gap <= jumpSize + 1) {
+        if (helper(stones, i, gap, memo) == 1) {
+          memo[idx][gap] = 1;
+          return 1;
+        }
+      }
+    }
+    memo[idx][jumpSize] = (idx == stones.length - 1) ? 1 : 0;
+    return memo[idx][jumpSize];
+  }
+}
diff --git a/Medium/Maximum Size Subarray Sum Equals k.java b/Medium/Maximum Size Subarray Sum Equals k.java
index a8d97e05..97d37973 100644
--- a/Medium/Maximum Size Subarray Sum Equals k.java	
+++ b/Medium/Maximum Size Subarray Sum Equals k.java	
@@ -1,23 +1,18 @@
 class Solution {
-    public static int maxSubArrayLen(int[] nums, int k) {
-        Map<Integer, Integer> map = new HashMap<>();
-        int sum = 0;
-        int max = 0;
-
-        map.put(0, -1);
-
-        for (int i=0; i<nums.length; i++) {
-            sum += nums[i];
-            int diff = sum - k;
-            if (map.containsKey(diff)) {
-                max = Math.max(max, i - map.get(diff));
-            }
-            
-            if (!map.containsKey(sum)) {
-                    map.put(sum, i);
-            }
-        }
-
-        return max;
+  public int maxSubArrayLen(int[] nums, int k) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int res = 0;
+    int sum = 0;
+    for (int i = 0; i < nums.length; i++) {
+      sum += nums[i];
+      if (sum == k) {
+        res = i + 1;
+      }
+      else if (map.containsKey(sum - k)) {
+        res = Math.max(res, i - map.get(sum - k));
+      }
+      map.putIfAbsent(sum, i);
     }
+    return res;
+  }
 }
diff --git a/Medium/Next Greater Element II.java b/Medium/Next Greater Element II.java
index 1da2f6a0..367351ae 100644
--- a/Medium/Next Greater Element II.java	
+++ b/Medium/Next Greater Element II.java	
@@ -1,25 +1,23 @@
 class Solution {
-    public int[] nextGreaterElements(int[] nums) {
-        int[] ans = new int[nums.length];
-        for (int i=0;i<nums.length;i++) {
-            ans[i] = -1;
-        }
-        
-        for (int i=0;i<nums.length;i++) {
-            int j = i+1;
-            while (true) {
-                if (j == nums.length) {
-                    j = 0;
-                }
-                if (j == i) break;
-                if (nums[j] > nums[i]) {
-                    ans[i] = nums[j];
-                    break;
-                }
-                j++;
-            }
+  public int[] nextGreaterElements(int[] nums) {
+    int[] ans = new int[nums.length];
+    Stack<Integer> stack = new Stack<>();
+    for (int i = nums.length - 1; i >= 0; i--) {
+      while (!stack.isEmpty() && nums[stack.peek()] <= nums[i]) {
+        stack.pop();
+      }
+      ans[i] = stack.isEmpty() ? -1 : nums[stack.peek()];
+      stack.push(i);
+    }
+    for (int i = nums.length - 1; i >= 0; i--) {
+      if (ans[i] == -1) {
+        while (!stack.isEmpty() && nums[stack.peek()] <= nums[i]) {
+          stack.pop();
         }
-        
-        return ans;
+        ans[i] = stack.isEmpty() ? -1 : nums[stack.peek()];
+      }
+      stack.push(i);
     }
+    return ans;
+  }
 }

From dda4aced4899411fae07322783100cc8731dc8a3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 21 Mar 2020 15:56:03 -0700
Subject: [PATCH 0130/2175] Added 3 solutions & modified 2 solutions

---
 ...the Distance Value Between Two Arrays.java | 18 +++++++++
 Easy/Symmetric Tree.java                      | 38 +++++++++----------
 Medium/Cinema Seat Allocation.java            | 29 ++++++++++++++
 Medium/Snakes and Ladders.java                | 34 +++++++++++++++++
 Medium/Word Break.java                        | 32 +++++++++-------
 5 files changed, 116 insertions(+), 35 deletions(-)
 create mode 100644 Easy/Find the Distance Value Between Two Arrays.java
 create mode 100644 Medium/Cinema Seat Allocation.java
 create mode 100644 Medium/Snakes and Ladders.java

diff --git a/Easy/Find the Distance Value Between Two Arrays.java b/Easy/Find the Distance Value Between Two Arrays.java
new file mode 100644
index 00000000..69df4f37
--- /dev/null
+++ b/Easy/Find the Distance Value Between Two Arrays.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int findTheDistanceValue(int[] arr1, int[] arr2, int d) {
+    TreeSet<Integer> set = new TreeSet<>();
+    for (int num : arr2) {
+      set.add(num);
+    }
+    int count = 0;
+    for (int num : arr1) {
+      Integer higher = set.ceiling(num);
+      Integer lower = set.floor(num);
+      if ((higher != null && Math.abs(higher - num) <= d) || (lower != null && Math.abs(lower - num) <= d)) {
+        continue;  
+      }
+      count++;
+    }
+    return count;
+  }
+}
diff --git a/Easy/Symmetric Tree.java b/Easy/Symmetric Tree.java
index bfc8e3eb..c50a5256 100644
--- a/Easy/Symmetric Tree.java	
+++ b/Easy/Symmetric Tree.java	
@@ -8,27 +8,23 @@
  * }
  */
 class Solution {
-    public boolean isSymmetric(TreeNode root) {
-        if (root == null) return true;
-        return isSymmetric(root.left, root.right);
+  public boolean isSymmetric(TreeNode root) {
+    if (root == null) {
+      return true;
     }
-    
-    public boolean isSymmetric(TreeNode left, TreeNode right) {
-        if (left == null && right == null) {
-            return true;
-        }
-        else if (left == null && right != null) {
-            return false;
-        }
-        else if (left != null && right == null) {
-            return false;
-        }
-        else if (left != null && right != null) {
-            if (left.val != right.val) {
-                return false;
-            }
-        }
-        
-        return isSymmetric(left.left, right.right) && isSymmetric(left.right, right.left);
+    return helper(root.left, root.right);
+  }
+  
+  private boolean helper(TreeNode r, TreeNode l) {
+    if (r == null && l == null) {
+      return true;
     }
+    if (r == null || l == null) {
+      return false;
+    }
+    if (r.val != l.val) {
+      return false;
+    }
+    return helper(l.left, r.right) && helper(l.right, r.left);
+  }
 }
diff --git a/Medium/Cinema Seat Allocation.java b/Medium/Cinema Seat Allocation.java
new file mode 100644
index 00000000..946d5839
--- /dev/null
+++ b/Medium/Cinema Seat Allocation.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int maxNumberOfFamilies(int n, int[][] reservedSeats) {
+    int numOfReservedSeats = reservedSeats.length;
+    Map<Integer, HashSet<Integer>> map = new HashMap<>();
+    for(int i = 0; i < numOfReservedSeats; i++) {
+      if(!map.containsKey(reservedSeats[i][0])) {
+        map.put(reservedSeats[i][0], new HashSet<>());
+      }
+      map.get(reservedSeats[i][0]).add(reservedSeats[i][1]);
+    }
+    int count = 2 * n - 2 * map.size();
+    for(Integer i : map.keySet()) {
+      boolean flag = false;
+      Set<Integer> reserved = map.get(i);
+      if(!reserved.contains(2) && !reserved.contains(3) && !reserved.contains(4) && !reserved.contains(5)) {
+        count++;
+        flag = true;
+      }
+      if(!reserved.contains(6) && !reserved.contains(7) && !reserved.contains(8) && !reserved.contains(9)) {
+        count++;
+        flag = true;
+      }
+      if(!flag && !reserved.contains(4) && !reserved.contains(5) && !reserved.contains(6) && !reserved.contains(7)) {
+        count++;
+      }
+    }
+    return count;
+  }
+}
diff --git a/Medium/Snakes and Ladders.java b/Medium/Snakes and Ladders.java
new file mode 100644
index 00000000..4c44f976
--- /dev/null
+++ b/Medium/Snakes and Ladders.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public int snakesAndLadders(int[][] board) {
+    int n = board.length;
+    Map<Integer, Integer> map = new HashMap<>();
+    map.put(1, 0);
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(1);
+    while (!queue.isEmpty()) {
+      int s = queue.remove();
+      if (s == n * n) {
+        return map.get(s);
+      }
+      for (int i = s + 1; i <= Math.min(s + 6, n * n); i++) {
+        int rc = helper(i, n);
+        int r = rc / n;
+        int c = rc % n;
+        int point = board[r][c] == -1 ? i : board[r][c];
+        if (!map.containsKey(point)) {
+          map.put(point, map.get(s) + 1);
+          queue.add(point);
+        }
+      }
+    }
+    return -1;
+  }
+  
+  public int helper(int s, int N) {
+    int quot = (s - 1) / N;
+    int rem = (s - 1) % N;
+    int row = N - 1 - quot;
+    int col = row % 2 != N % 2 ? rem : N - 1 - rem;
+    return row * N + col;
+  }
+}
diff --git a/Medium/Word Break.java b/Medium/Word Break.java
index e79bd39f..e678079f 100644
--- a/Medium/Word Break.java	
+++ b/Medium/Word Break.java	
@@ -1,19 +1,23 @@
 class Solution {
-    public boolean wordBreak(String s, List<String> wordDict) {
-        Set<String> wordDictSet=new HashSet(wordDict);
-
-        boolean[] dp = new boolean[s.length() + 1];
-        dp[0] = true;
-
-        for (int i = 1; i <= s.length(); i++) {
-            for (int j = 0; j < i; j++) {
-                if (dp[j] && wordDictSet.contains(s.substring(j, i))) {
-                    dp[i] = true;
-                    break;
-                }
+  public boolean wordBreak(String s, List<String> wordDict) {
+    Set<String> set = new HashSet<>(wordDict);
+    Queue<Integer> queue = new LinkedList<>();
+    int[] visited = new int[s.length()];
+    queue.add(0);
+    while (!queue.isEmpty()) {
+      int start = queue.remove();
+      if (visited[start] == 0) {
+        for (int end = start + 1; end <= s.length(); end++) {
+          if (set.contains(s.substring(start, end))) {
+            queue.add(end);
+            if (end == s.length()) {
+              return true;
             }
+          }
         }
-
-        return dp[s.length()];
+        visited[start] = 1;
+      }
     }
+    return false;
+  }   
 }

From 3786ca4901ab896284486703e4b629c8b546de3d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 22 Mar 2020 15:33:58 -0700
Subject: [PATCH 0131/2175] Added 1 solution & modified 1 solution

---
 Medium/Number of Distinct Islands.java      | 60 +++++++++++----------
 Medium/Path With Maximum Minimum Value.java | 34 ++++++++++++
 2 files changed, 67 insertions(+), 27 deletions(-)
 create mode 100644 Medium/Path With Maximum Minimum Value.java

diff --git a/Medium/Number of Distinct Islands.java b/Medium/Number of Distinct Islands.java
index f43442f3..d33af963 100644
--- a/Medium/Number of Distinct Islands.java	
+++ b/Medium/Number of Distinct Islands.java	
@@ -1,32 +1,38 @@
 class Solution {
-    public int numDistinctIslands(int[][] grid) {
-        Set<String> numOfIslands = new HashSet<>();
-        
-        for (int i=0; i<grid.length; i++) {
-            for (int j=0; j<grid[i].length; j++) {
-                if (grid[i][j] == 1) {
-                    StringBuilder sb = new StringBuilder("f");
-                    String island = dfsHelper(grid, i, j, sb);
-                    numOfIslands.add(island);
-                }
-            }
-        }
-        
-        return numOfIslands.size();
+  Set<String> set;
+  int[][] dirs = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
+  public int numDistinctIslands(int[][] grid) {
+    if (grid.length == 0 || grid[0].length == 0) {
+      return 0;
     }
-    
-    private String dfsHelper(int[][] grid, int row, int col, StringBuilder sb) {
-        if (row == grid.length || row < 0 || col == grid[row].length || col < 0 || grid[row][col] == 0) {
-            return sb.toString();
+    set = new HashSet<>();
+    boolean[][] visited = new boolean[grid.length][grid[0].length];
+    for (int i = 0; i < grid.length; i++) {
+      for (int j = 0; j < grid[i].length; j++) {
+        if (!visited[i][j]) {
+          StringBuilder sb = new StringBuilder();
+          dfs(grid, i, j, visited, sb, 0);
+          if (sb.length() > 0) {
+            set.add(sb.toString());
+          }
         }
-        
-        grid[row][col] = 0;
-        
-        sb.append(dfsHelper(grid, row - 1, col, new StringBuilder("u")));
-        sb.append(dfsHelper(grid, row, col + 1, new StringBuilder("r")));
-        sb.append(dfsHelper(grid, row + 1, col, new StringBuilder("d")));
-        sb.append(dfsHelper(grid, row, col - 1, new StringBuilder("l")));
-        
-        return sb.toString();
+      }
+    }
+    return set.size();
+  }
+  
+  private void dfs(int[][] grid, int x, int y, boolean[][] visited, StringBuilder sb, int currDir) {
+    if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] != 1 || visited[x][y]) {
+      return;
+    }
+    sb.append(currDir);
+    visited[x][y] = true;
+    int curr = 1;
+    for (int[] dir : dirs) {
+      int newX = x + dir[0];
+      int newY = y + dir[1];
+      dfs(grid, newX, newY, visited, sb, curr++);
     }
+    sb.append(0);
+  }
 }
diff --git a/Medium/Path With Maximum Minimum Value.java b/Medium/Path With Maximum Minimum Value.java
new file mode 100644
index 00000000..d2204779
--- /dev/null
+++ b/Medium/Path With Maximum Minimum Value.java	
@@ -0,0 +1,34 @@
+class Solution {
+  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public int maximumMinimumPath(int[][] A) {
+    int rows = A.length;
+    int cols = A[0].length;
+    boolean[][] visited = new boolean[rows][cols];
+    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
+      public int compare(int[] p1, int[] p2) {
+        return p2[0] - p1[0];
+      }
+    });
+    int maxVal = A[0][0];
+    pq.add(new int[]{A[0][0], 0, 0});
+    visited[0][0] = true;
+    while (!pq.isEmpty()) {
+      int[] removed = pq.poll();
+      int x = removed[1];
+      int y = removed[2];
+      maxVal = Math.min(maxVal, removed[0]);
+      if (x == rows - 1 && y == cols - 1) {
+        break;
+      }
+      for (int[] dir : dirs) {
+        int newX = x + dir[0];
+        int newY = y + dir[1];
+        if (newX >= 0 && newY >= 0 && newX < rows && newY < cols && !visited[newX][newY]) {
+          pq.add(new int[]{A[newX][newY], newX, newY});
+          visited[newX][newY] = true;
+        }
+      }
+    }
+    return maxVal;
+  }
+}

From 933abcf9517e50640103403ce9b9fd168c193659 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 23 Mar 2020 08:03:53 -0700
Subject: [PATCH 0132/2175] Added 3 solutions

---
 ...reate Target Array in the Given Order.java | 13 +++++++
 ...ck if There is a Valid Path in a Grid.java | 39 +++++++++++++++++++
 Medium/Four Divisors.java                     | 22 +++++++++++
 3 files changed, 74 insertions(+)
 create mode 100644 Easy/Create Target Array in the Given Order.java
 create mode 100644 Medium/Check if There is a Valid Path in a Grid.java
 create mode 100644 Medium/Four Divisors.java

diff --git a/Easy/Create Target Array in the Given Order.java b/Easy/Create Target Array in the Given Order.java
new file mode 100644
index 00000000..126b0e5c
--- /dev/null
+++ b/Easy/Create Target Array in the Given Order.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int[] createTargetArray(int[] nums, int[] index) {
+    List<Integer> list = new ArrayList<>();
+    for (int i = 0; i < nums.length; i++) {
+      list.add(index[i], nums[i]);
+    }
+    int[] ans = new int[list.size()];
+    for (int i = 0; i < list.size(); i++) {
+      ans[i] = list.get(i);
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Check if There is a Valid Path in a Grid.java b/Medium/Check if There is a Valid Path in a Grid.java
new file mode 100644
index 00000000..bb3af343
--- /dev/null
+++ b/Medium/Check if There is a Valid Path in a Grid.java	
@@ -0,0 +1,39 @@
+class Solution {
+  public boolean hasValidPath(int[][] grid) {
+    int[][][] dirs = {
+      {{0, -1}, {0, 1}},
+      {{-1, 0}, {1, 0}},
+      {{0, -1}, {1, 0}},
+      {{0, 1}, {1, 0}},
+      {{0, -1}, {-1, 0}},
+      {{0, 1}, {-1, 0}}
+    };
+    int rows = grid.length;
+    int cols = grid[0].length;
+    Queue<int[]> queue = new LinkedList<>();
+    boolean[][] visited = new boolean[rows][cols];
+    queue.add(new int[]{0, 0});
+    visited[0][0] = true;
+    while (!queue.isEmpty()) {
+      int[] curr = queue.remove();
+      int x = curr[0];
+      int y = curr[1];
+      int num = grid[x][y] - 1;
+      for (int[] dir : dirs[num]) {
+        int newX = x + dir[0];
+        int newY = y + dir[1];
+        // Check if valid co-ordinate
+        if (newX >= 0 && newX < grid.length && newY >= 0 && newY < grid[0].length && !visited[newX][newY]) {
+          for (int[] prevDir : dirs[grid[newX][newY] - 1]) {
+            // Check if connected to previous direction
+            if (newX + prevDir[0] == x && newY + prevDir[1] == y) {
+              visited[newX][newY] = true;
+              queue.add(new int[]{newX, newY});
+            }
+          }
+        }
+      }
+    }
+    return visited[rows - 1][cols - 1];
+  }
+}
diff --git a/Medium/Four Divisors.java b/Medium/Four Divisors.java
new file mode 100644
index 00000000..4b391129
--- /dev/null
+++ b/Medium/Four Divisors.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int sumFourDivisors(int[] nums) {
+    int sum = 0;
+    for (int num : nums) {
+      Set<Integer> set = new HashSet<>();
+      for (int i = 1; i <= Math.sqrt(num); i++) {
+        int first = i;
+        int second = num % i;
+        if (second == 0) {
+          set.add(first);
+          set.add(num / i);
+        }
+      }
+      if (set.size() == 4) {
+        for (int d : set) {
+          sum += d;
+        }
+      }
+    }
+    return sum;
+  }
+}

From 0446b7a43632deda83c61a70ed71dfb95f4e5f0e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 24 Mar 2020 22:15:30 -0700
Subject: [PATCH 0133/2175] Added 1 solution & modified 4 solutions

---
 Easy/Excel Sheet Column Number.java |  15 ++---
 Easy/Robot Return to Origin.java    |  18 +++++
 Easy/Valid Anagram.java             |  17 +++++
 Easy/valid_anagrams.java            |  12 ----
 Medium/Meeting Rooms II.java        | 101 +++++++---------------------
 Medium/Word Search.java             |  77 +++++++++------------
 6 files changed, 98 insertions(+), 142 deletions(-)
 create mode 100644 Easy/Robot Return to Origin.java
 create mode 100644 Easy/Valid Anagram.java
 delete mode 100644 Easy/valid_anagrams.java

diff --git a/Easy/Excel Sheet Column Number.java b/Easy/Excel Sheet Column Number.java
index a75e2708..dc59608e 100644
--- a/Easy/Excel Sheet Column Number.java	
+++ b/Easy/Excel Sheet Column Number.java	
@@ -1,11 +1,10 @@
 class Solution {
-    public int titleToNumber(String s) {
-        int pow = 0;
-        int count = 0;
-        for (int i = s.length() - 1; i >= 0; i--) {
-            count += ((int) Math.pow(26, pow++)) * (s.charAt(i) - 'A' + 1);
-        }
-        
-        return count;
+  public int titleToNumber(String s) {
+    int num = 0;
+    int pow = 0;
+    for (int i = s.length() - 1; i >= 0; i--) {
+      num += ((int) Math.pow(26, pow++)) * (s.charAt(i) - 'A' + 1);
     }
+    return num;
+  }
 }
diff --git a/Easy/Robot Return to Origin.java b/Easy/Robot Return to Origin.java
new file mode 100644
index 00000000..978c30d6
--- /dev/null
+++ b/Easy/Robot Return to Origin.java	
@@ -0,0 +1,18 @@
+class Solution {
+  Map<Character, int[]> map;
+  public boolean judgeCircle(String moves) {
+    map = new HashMap<>();
+    map.put('U', new int[]{-1, 0});
+    map.put('D', new int[]{1, 0});
+    map.put('L', new int[]{0, -1});
+    map.put('R', new int[]{0, 1});
+    int x = 0;
+    int y = 0;
+    for (char c : moves.toCharArray()) {
+      int[] dir = map.get(c);
+      x += dir[0];
+      y += dir[1];
+    }
+    return x == 0 && y == 0;
+  }
+}
diff --git a/Easy/Valid Anagram.java b/Easy/Valid Anagram.java
new file mode 100644
index 00000000..5bf5d251
--- /dev/null
+++ b/Easy/Valid Anagram.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean isAnagram(String s, String t) {
+    int[] counter = new int[26];
+    for (char c : s.toCharArray()) {
+      counter[c - 'a']++;
+    }
+    for (char c : t.toCharArray()) {
+      counter[c - 'a']--;
+    }
+    for (int i = 0; i < 26; i++) {
+      if (counter[i] != 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
diff --git a/Easy/valid_anagrams.java b/Easy/valid_anagrams.java
deleted file mode 100644
index c27826e8..00000000
--- a/Easy/valid_anagrams.java
+++ /dev/null
@@ -1,12 +0,0 @@
-import java.util.Arrays;
-public class Solution {
-    public boolean isAnagram(String s, String t) {
-            char[] schar = s.toCharArray();
-            char[] tchar = t.toCharArray();
-            Arrays.sort(schar);
-            Arrays.sort(tchar);
-            s = new String(schar);
-            t = new String(tchar);
-            return s.equals(t);
-        }
-    }
diff --git a/Medium/Meeting Rooms II.java b/Medium/Meeting Rooms II.java
index 5dd2621a..e327a24a 100644
--- a/Medium/Meeting Rooms II.java	
+++ b/Medium/Meeting Rooms II.java	
@@ -1,80 +1,29 @@
-/**
- * Definition for an interval.
- * public class Interval {
- *     int start;
- *     int end;
- *     Interval() { start = 0; end = 0; }
- *     Interval(int s, int e) { start = s; end = e; }
- * }
- */
 class Solution {
-    public static int minMeetingRooms(Interval[] intervals) {
-
-        if (intervals.length == 0) {
-            return 0;
+  public int minMeetingRooms(int[][] intervals) {
+    Arrays.sort(intervals, new Comparator<int[]>() {
+      @Override
+      public int compare(int[] o1, int[] o2) {
+        int c = o1[0] - o2[0];
+        if (c != 0) {
+          return c;
         }
-
-        int[] start = new int[intervals.length];
-        int[] end = new int[intervals.length];
-
-        int i = 0;
-
-        for (Interval interval : intervals) {
-            start[i] = interval.start;
-            end[i] = interval.end;
-
-            i++;
-        }
-
-        Arrays.sort(start);
-        Arrays.sort(end);
-
-        int slow = 0;
-        int fast = 0;
-        int count = 0;
-
-        while (slow < intervals.length) {
-            if (start[slow] >= end[fast]) {
-                count--;
-                fast++;
-            }
-
-            count++;
-            slow++;
-        }
-
-        return count;
-    }
-    
-    public static int minMeetingRoomsQueue(Interval[] intervals) {
-        if (intervals.length == 0) {
-            return 0;
-        }
-
-        PriorityQueue<Integer> endTimes = new PriorityQueue<>(intervals.length, new Comparator<Integer>() {
-            @Override
-            public int compare(Integer o1, Integer o2) {
-                return o1 - o2;
-            }
-        });
-
-        Arrays.sort(intervals, new Comparator<Interval>() {
-            @Override
-            public int compare(Interval o1, Interval o2) {
-                return o1.start - o2.start;
-            }
-        });
-
-        endTimes.add(intervals[0].end);
-
-        for (int i=1; i<intervals.length; i++) {
-            if (intervals[i].start >= endTimes.peek()) {
-                endTimes.poll();
-            }
-
-            endTimes.add(intervals[i].end);
-        }
-
-        return endTimes.size();
+        return o1[1] - o2[1];
+      }
+    });
+    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
+      @Override
+      public int compare(int[] o1, int[] o2) {
+        return o1[1] - o2[1];
+      }
+    });
+    int maxCount = 0;
+    for (int i = 0; i < intervals.length; i++) {
+      while (!pq.isEmpty() && pq.peek()[1] <= intervals[i][0]) {
+        pq.poll();
+      }
+      pq.add(intervals[i]);
+      maxCount = Math.max(maxCount, pq.size());
     }
+    return maxCount;
+  }
 }
diff --git a/Medium/Word Search.java b/Medium/Word Search.java
index 8f6b43c3..3aa0d784 100644
--- a/Medium/Word Search.java	
+++ b/Medium/Word Search.java	
@@ -1,51 +1,36 @@
 class Solution {
-    public boolean exist(char[][] board, String word) {
-        if (board == null || word == null || word.length() == 0) {
-            return false;
+  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public boolean exist(char[][] board, String word) {
+    int rows = board.length;
+    int cols = board[0].length;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (dfs(board, i, j, word, 0, new boolean[rows][cols], rows, cols)) {
+          return true;
         }
-
-        int[][] dirs = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
-        int row = board.length;
-        int col = board[0].length;
-
-        boolean[][] visited = new boolean[row][col];
-        for (int i=0; i<row; i++) {
-            for (int j=0; j<col; j++) {
-                if (dfs(board, i, j, word, 0, row, col, visited, dirs)) {
-                    return true;
-                }
-            }
-        }
-
-        return false;
+      }
     }
-
-    private boolean dfs(char[][] board, int i, int j, String word, int start, int row, int col, boolean[][] visited, int[][] dirs) {
-        if (board[i][j] != word.charAt(start)) {
-            return false;
-        }
-
-        if (start + 1 == word.length()) {
-            return true;
-        }
-
-        visited[i][j] = true;
-        for (int[] dir : dirs) {
-            int x = i + dir[0];
-            int y = j + dir[1];
-
-            if (x < 0 || y < 0 || x >= row || y >= col || visited[x][y]) {
-                continue;
-            }
-
-            if (dfs(board, x, y, word, start + 1, row, col, visited, dirs)) {
-                return true;
-            }
-        }
-
-        visited[i][j] = false;
-
-        return false;
+    return false;
+  }
+  
+  private boolean dfs(char[][] board, int x, int y, String s, int idx, 
+                      boolean[][] visited, int rows, int cols) {
+    if (idx == s.length()) {
+      return true;
+    }
+    if (x < 0 || x >= rows || y < 0 || y >= cols || visited[x][y]) {
+      return false;
+    }
+    if (s.charAt(idx) != board[x][y]) {
+      return false;
+    }
+    visited[x][y] = true;
+    for (int[] dir : dirs) {
+      if (dfs(board, x + dir[0], y + dir[1], s, idx + 1, visited, rows, cols)) {
+        return true;
+      }
     }
-
+    visited[x][y] = false;
+    return false;
+  }
 }

From 6b57a723ea3a753ffa7ac4220f76d642decd4400 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 25 Mar 2020 15:16:29 -0700
Subject: [PATCH 0134/2175] Modified 6 solutions

---
 Easy/1-bit and 2-bit Characters.java      | 28 ++++++-----
 Easy/Backspace String Compare.java        | 57 ++++++++++++++++-------
 Easy/Kth Largest Element in a Stream.java | 37 +++++++--------
 Easy/Logger Rate Limiter.java             | 31 ++++++------
 Easy/Pascal's Triangle.java               | 34 ++++++--------
 Medium/Maximum Width of Binary Tree.java  | 48 ++++++-------------
 6 files changed, 118 insertions(+), 117 deletions(-)

diff --git a/Easy/1-bit and 2-bit Characters.java b/Easy/1-bit and 2-bit Characters.java
index 90f44fbf..c2031613 100644
--- a/Easy/1-bit and 2-bit Characters.java	
+++ b/Easy/1-bit and 2-bit Characters.java	
@@ -1,16 +1,20 @@
 class Solution {
-    public boolean isOneBitCharacter(int[] bits) {
-        int l = bits.length;
-        int i = 0;
-        
-        while(i<l-1) {
-            if(bits[i] == 0) {
-                i++;
-            }
-            else {
-                i += 2;
-            }
+  public boolean isOneBitCharacter(int[] bits) {
+    int idx = 0;
+    int n = bits.length; 
+    while (idx < n) {
+      if (bits[idx] == 1) {
+        if (idx + 1 == n - 1) {
+          return false;
         }
-        return i == l-1;
+        else {
+          idx += 2;
+        }
+      }
+      else {
+        idx++;
+      }
     }
+    return true;
+  }
 }
diff --git a/Easy/Backspace String Compare.java b/Easy/Backspace String Compare.java
index 604ae07d..b480d09f 100644
--- a/Easy/Backspace String Compare.java	
+++ b/Easy/Backspace String Compare.java	
@@ -1,20 +1,45 @@
 class Solution {
-    public boolean backspaceCompare(String S, String T) {
-        return getEncodedString(S).equals(getEncodedString(T));
-    }
-    
-    private String getEncodedString(String s) {
-        StringBuilder sb = new StringBuilder();
-        
-        for (char c : s.toCharArray()) {
-            if (c != '#') {
-                sb.append(c);
-            }
-            else if (sb.length() > 0) {
-                sb.deleteCharAt(sb.length() - 1);
-            }
+  public boolean backspaceCompare(String S, String T) {
+    int i = S.length() - 1;
+    int j = T.length() - 1;
+    int skipS = 0;
+    int skipT = 0;
+    while (i >= 0 || j >= 0) {
+      while (i >= 0) {
+        if (S.charAt(i) == '#') {
+          skipS++;
+          i--;
+        }
+        else if (skipS > 0) {
+          skipS--;
+          i--;
+        }
+        else {
+          break;
+        }
+      }
+      while (j >= 0) {
+        if (T.charAt(j) == '#') {
+          skipT++;
+          j--;
+        }
+        else if (skipT > 0) {
+          skipT--;
+          j--;
+        }
+        else {
+          break;
         }
-        
-        return sb.toString();
+      }
+      if (i >= 0 && j >= 0 && S.charAt(i) != T.charAt(j)) {
+        return false;
+      }
+      if ((i >= 0) != (j >= 0)) {
+        return false;
+      }
+      i--;
+      j--;
     }
+    return true;
+  }
 }
diff --git a/Easy/Kth Largest Element in a Stream.java b/Easy/Kth Largest Element in a Stream.java
index 5e701906..e3ab89a0 100644
--- a/Easy/Kth Largest Element in a Stream.java	
+++ b/Easy/Kth Largest Element in a Stream.java	
@@ -1,27 +1,24 @@
 class KthLargest {
-    PriorityQueue<Integer> priorityQueue;
-    int k;
-
-    public KthLargest(int k, int[] nums) {
-        this.k = k;
-        priorityQueue = new PriorityQueue<>(k);
-
-        for (int num : nums) {
-            priorityQueue.offer(num);
-            if (priorityQueue.size() > k) {
-                priorityQueue.poll();
-            }
-        }
+  PriorityQueue<Integer> pq;
+  int k;
+  public KthLargest(int k, int[] nums) {
+    pq = new PriorityQueue<>();
+    this.k = k;
+    for (int num : nums) {
+      add(num);
     }
+  }
 
-    public int add(int val) {
-        priorityQueue.offer(val);
-        if (priorityQueue.size() > k) {
-            priorityQueue.poll();
-        }
-
-        return priorityQueue.peek();
+  public int add(int num) {
+    if (pq.size() < k) {
+      pq.add(num);
+    }
+    else if (pq.peek() < num) {
+      pq.poll();
+      pq.add(num);
     }
+    return pq.peek();
+  }
 }
 
 /**
diff --git a/Easy/Logger Rate Limiter.java b/Easy/Logger Rate Limiter.java
index b63decd4..3e637371 100644
--- a/Easy/Logger Rate Limiter.java	
+++ b/Easy/Logger Rate Limiter.java	
@@ -1,24 +1,21 @@
 class Logger {
 
-    /** Initialize your data structure here. */
-    Map<String, Integer> map;
-    public Logger() {
-        map = new HashMap<>();
-    }
-
-    /** Returns true if the message should be printed in the given timestamp, otherwise returns false.
-     If this method returns false, the message will not be printed.
-     The timestamp is in seconds granularity. */
-    public boolean shouldPrintMessage(int timestamp, String message) {
-
-        if (map.containsKey(message) && timestamp - map.get(message) < 10) {
-            return false;
-        }
-
-        map.put(message, timestamp);
+  /** Initialize your data structure here. */
+  Map<String, Integer> map;
+  public Logger() {
+    map = new HashMap<>();
+  }
 
-        return true;
+  /** Returns true if the message should be printed in the given timestamp, otherwise returns false.
+      If this method returns false, the message will not be printed.
+      The timestamp is in seconds granularity. */
+  public boolean shouldPrintMessage(int timestamp, String message) {
+    if (map.containsKey(message) && (timestamp - map.get(message)) < 10) {
+      return false;
     }
+    map.put(message, timestamp);
+    return true;
+  }
 }
 
 /**
diff --git a/Easy/Pascal's Triangle.java b/Easy/Pascal's Triangle.java
index ac462848..5b3b7b8b 100644
--- a/Easy/Pascal's Triangle.java	
+++ b/Easy/Pascal's Triangle.java	
@@ -1,23 +1,19 @@
 class Solution {
-   
-    public List<List<Integer>> generate(int numRows) {
-   
-        List<List<Integer>> ans = new ArrayList<>();
-        
-        for (int i=0;i<numRows;i++) {
-            List<Integer> temp = new ArrayList<>();
-            for(int j = 0;j<=i;j++) {
-                if (i == j || j == 0) {
-                    temp.add(1);
-                }
-                else {
-                    temp.add(ans.get(i-1).get(j-1) + ans.get(i-1).get(j));
-                }
-            }
-            
-            ans.add(temp);
+  public List<List<Integer>> generate(int numRows) {
+    List<List<Integer>> ans = new ArrayList<>();
+    for (int i = 0; i < numRows; i++) {
+      List<Integer> list = new ArrayList<>();
+      for (int j = 0; j < i + 1; j++) {
+        if (j == 0 || j == i) {
+          list.add(1);
         }
-        
-        return ans;
+        else {
+          list.add(ans.get(i - 1).get(j - 1) + ans.get(i - 1).get(j));
+        }
+      }
+      System.out.println(list);
+      ans.add(list);
     }
+    return ans;
+  }
 }
diff --git a/Medium/Maximum Width of Binary Tree.java b/Medium/Maximum Width of Binary Tree.java
index 0cccc71c..a236cec3 100644
--- a/Medium/Maximum Width of Binary Tree.java	
+++ b/Medium/Maximum Width of Binary Tree.java	
@@ -8,38 +8,20 @@
  * }
  */
 class Solution {
-    public int widthOfBinaryTree(TreeNode root) {
-        if (root == null) {
-            return 1;
-        }
-        
-        int size = 0;
-        Queue<TreeNode> queue = new LinkedList<>();
-        Map<TreeNode, Integer> map = new HashMap<>();
-        map.put(root, 0);
-        queue.add(root);
-        
-        while (!queue.isEmpty()) {
-            int len = queue.size();
-            int leftPos = map.get(queue.peek());
-            
-            for (int i=0; i<len; i++) {
-                TreeNode popped = queue.remove();
-                int currPos = map.get(popped);
-                size = Math.max(size, currPos - leftPos + 1);
-                
-                if (popped.left != null) {
-                    queue.add(popped.left);
-                    map.put(popped.left, 2 * currPos);
-                }
-                
-                if (popped.right != null) {
-                    queue.add(popped.right);
-                    map.put(popped.right, 2 * currPos + 1);
-                }
-            }
-        }
-        
-        return size;
+  public int widthOfBinaryTree(TreeNode root) {
+    int[] ans = {0};
+    Map<Integer, Integer> map = new HashMap<>();
+    dfs(root, 0, 0, ans, map);
+    return ans[0];
+  }
+  
+  private void dfs(TreeNode root, int depth, int pos, int[] ans, Map<Integer, Integer> map) {
+    if (root == null) {
+      return;
     }
+    map.putIfAbsent(depth, pos);
+    ans[0] = Math.max(ans[0], pos - map.get(depth) + 1);
+    dfs(root.left, depth + 1, 2 * pos, ans, map);
+    dfs(root.right, depth + 1, 2 * pos + 1, ans, map);
+  }
 }

From 4eec0631c99e7cfdeaaa27ba1df06c71e1b68c3e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 25 Mar 2020 20:08:49 -0700
Subject: [PATCH 0135/2175] Modified 2 solutions

---
 Easy/Strobogrammatic Number.java              | 29 +++++++++----------
 ...Remove Duplicates from Sorted List II.java | 29 +++++++++----------
 2 files changed, 27 insertions(+), 31 deletions(-)

diff --git a/Easy/Strobogrammatic Number.java b/Easy/Strobogrammatic Number.java
index 70e41872..c258a0c2 100644
--- a/Easy/Strobogrammatic Number.java	
+++ b/Easy/Strobogrammatic Number.java	
@@ -1,18 +1,17 @@
 class Solution {
-    public boolean isStrobogrammatic(String num) {
-        StringBuilder sb = new StringBuilder();
-        for (char c : num.toCharArray()) {
-            if (c == '0' || c == '1' || c == '8') {
-                sb.append(c);
-            }
-            else if (c == '6' || c == '9') {
-                sb.append(c == '6' ? '9' : '6');
-            }
-            else {
-                return false;
-            }
-        }
-        
-        return sb.reverse().toString().equals(num);
+  public boolean isStrobogrammatic(String num) {
+    StringBuilder sb = new StringBuilder();
+    for (char c : num.toCharArray()) {
+      if (c == '0' || c == '1' || c == '8') {
+        sb.append(c);
+      }
+      else if (c == '6' || c == '9') {
+        sb.append(c == '6' ? '9' : '6');
+      }
+      else {
+        return false;
+      }
     }
+    return sb.reverse().toString().equals(num);
+  }
 }
diff --git a/Medium/Remove Duplicates from Sorted List II.java b/Medium/Remove Duplicates from Sorted List II.java
index 77c6672f..62a3b0e3 100644
--- a/Medium/Remove Duplicates from Sorted List II.java	
+++ b/Medium/Remove Duplicates from Sorted List II.java	
@@ -8,29 +8,26 @@
  */
 class Solution {
   public ListNode deleteDuplicates(ListNode head) {
-    ListNode dummy = new ListNode(0);
-    dummy.next = head;
-    ListNode prev = dummy;
     ListNode curr = head;
+    ListNode prev = null;
     while (curr != null) {
-      int val = curr.val;
-      int count = 0;
-      ListNode temp = curr;
-      // Track the number of occurrences of value of current node
-      while (temp != null && temp.val == val) {
-        temp = temp.next;
-        count++;
-      }
-      // Update prev.next to the temp which can be a null or node with different value
-      if (count > 1) {
-        prev.next = temp;
-        curr = temp;
+      if (curr.next != null && curr.val == curr.next.val) {
+        int currVal = curr.val;
+        while (curr != null && curr.val == currVal) {
+          curr = curr.next;
+        }
+        if (prev == null) {
+          head = curr;
+        }
+        else {
+          prev.next = curr;
+        }
       }
       else {
         prev = curr;
         curr = curr.next;
       }
     }
-    return dummy.next;
+    return head;
   }
 }

From 6219c7f226d11cf0af157ac5ac2fd301b3958757 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 26 Mar 2020 11:11:55 -0700
Subject: [PATCH 0136/2175] Added 1 solution & modified 1 solution

---
 Easy/Reorder Data in Log Files.java | 35 +++++++++++++++++++++++
 Medium/Generate Parentheses.java    | 43 +++++++++++++++++------------
 2 files changed, 60 insertions(+), 18 deletions(-)
 create mode 100644 Easy/Reorder Data in Log Files.java

diff --git a/Easy/Reorder Data in Log Files.java b/Easy/Reorder Data in Log Files.java
new file mode 100644
index 00000000..df293c3d
--- /dev/null
+++ b/Easy/Reorder Data in Log Files.java	
@@ -0,0 +1,35 @@
+class Solution {
+  public String[] reorderLogFiles(String[] logs) {
+    List<String> letterLogs = new ArrayList<>();
+    List<String> digitLogs = new ArrayList<>();
+    for (String log : logs) {
+      String[] strs = log.split("\\s+");
+      if (Character.isDigit(strs[1].charAt(0))) {
+        digitLogs.add(log);
+      }
+      else {
+        letterLogs.add(log);
+      }
+    }
+    Collections.sort(letterLogs, new Comparator<String>(){
+      public int compare(String s1, String s2) {
+        String key1 = s1.substring(s1.indexOf(' ') + 1);
+        String key2 = s2.substring(s2.indexOf(' ') + 1);
+        int c = key1.compareTo(key2);
+        if (c != 0) {
+          return c;
+        }
+        return s1.substring(0, s1.indexOf(' ')).compareTo(s2.substring(0, s2.indexOf(' ')));
+      }
+    });
+    String[] ans = new String[logs.length];
+    int idx = 0;
+    for (String log : letterLogs) {
+      ans[idx++] = log;
+    }
+    for (String log : digitLogs) {
+      ans[idx++] = log;
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Generate Parentheses.java b/Medium/Generate Parentheses.java
index 8666391d..7b311c92 100644
--- a/Medium/Generate Parentheses.java	
+++ b/Medium/Generate Parentheses.java	
@@ -1,23 +1,30 @@
 class Solution {
-    Set<String> set;
-    public List<String> generateParenthesis(int n) {
-        set = new HashSet<>();
-        helper(0, 0, new StringBuilder(), n);
-        return new ArrayList<>(set);
+  Set<String> set;
+  public List<String> generateParenthesis(int n) {
+    set = new HashSet<>();
+    StringBuilder sb = new StringBuilder();
+    helper(n, 0, 0, sb);
+    return new ArrayList<>(set);
+  }
+  
+  private void helper(int n, int open, int close, StringBuilder sb) {
+    if (sb.length() == 2 * n) {
+      set.add(sb.toString());
     }
-    
-    private void helper(int left, int right, StringBuilder sb, int n) {
-        if (left > n || right > n || left < right) {
-            return;
-        }
-        
-        if (left == right && left == n) {
-            set.add(sb.toString());
-        }
-        
-        helper(left + 1, right, sb.append('('), n);
-        sb.deleteCharAt(sb.length() - 1);
-        helper(left, right + 1, sb.append(')'), n);
+    else {
+      if (open <= close) {
+        sb.append('(');
+        helper(n, open + 1, close, new StringBuilder(sb.toString()));
+      }
+      else {
+        sb.append(')');
+        helper(n, open, close + 1, new StringBuilder(sb.toString()));
         sb.deleteCharAt(sb.length() - 1);
+        if (open < n) {
+          sb.append('(');
+          helper(n, open + 1, close, new StringBuilder(sb.toString())); 
+        }
+      }
     }
+  }
 }

From e511be1923c6467f349f5283247b185efbf5b2c8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 28 Mar 2020 12:39:59 -0700
Subject: [PATCH 0137/2175] Modified 6 solutions

---
 Easy/Climbing Stairs.java                     | 32 ++++++------
 ...d All Numbers Disappeared in an Array.java | 34 ++++++-------
 Easy/Maximum 69 Number.java                   | 23 ++++++---
 Easy/Nested List Weight Sum.java              | 36 ++++++++-----
 Easy/Squares of a Sorted Array.java           | 48 ++++++++++-------
 Medium/Nested List Weight Sum II.java         | 51 +++++++++----------
 6 files changed, 126 insertions(+), 98 deletions(-)

diff --git a/Easy/Climbing Stairs.java b/Easy/Climbing Stairs.java
index b29021af..e35175f2 100644
--- a/Easy/Climbing Stairs.java	
+++ b/Easy/Climbing Stairs.java	
@@ -1,18 +1,20 @@
 class Solution {
-    public int climbStairs(int n) {
-        if (n == 1) return 1;
-        if (n == 2) return 2;
-        
-        int oneStep = 2;
-        int twoStep = 1;
-        int all = 0;
-        
-        for (int i=2;i<n;i++) {
-            all = oneStep + twoStep;
-            twoStep = oneStep;
-            oneStep = all;
-        }
-        
-        return all;
+  int[] memo;
+  public int climbStairs(int n) {
+    if (n == 1) {
+      return 1;
     }
+    memo = new int[n + 1];
+    memo[1] = 1;
+    memo[2] = 2;
+    return helper(n);
+  }
+  
+  private int helper(int n) {
+    if (memo[n] != 0) {
+      return memo[n];
+    }
+    memo[n] = helper(n - 1) + helper(n - 2);
+    return memo[n];
+  }
 }
diff --git a/Easy/Find All Numbers Disappeared in an Array.java b/Easy/Find All Numbers Disappeared in an Array.java
index b1b53a91..4e3865b9 100644
--- a/Easy/Find All Numbers Disappeared in an Array.java	
+++ b/Easy/Find All Numbers Disappeared in an Array.java	
@@ -1,19 +1,17 @@
-public class Solution {
-    public List<Integer> findDisappearedNumbers(int[] nums) {
-        List<Integer> ans = new ArrayList<Integer>();
-        
-        for(int i = 0; i < nums.length; i++) {
-            int val = Math.abs(nums[i]) - 1;
-            if(nums[val] > 0) {
-                nums[val] = -nums[val];
-            }
-        }
-        
-        for(int i = 0; i < nums.length; i++) {
-            if(nums[i] > 0) {
-                ans.add(i+1);
-            }
-        }
-        return ans;
+class Solution {
+  public List<Integer> findDisappearedNumbers(int[] nums) {
+    for (int i = 0; i < nums.length; i++) {
+      int newIdx = Math.abs(nums[i]) - 1;
+      if (nums[newIdx] > 0) {
+        nums[newIdx] *= -1;
+      }
     }
-}
\ No newline at end of file
+    List<Integer> list = new ArrayList<>();
+    for (int i = 1; i <= nums.length; i++) {
+      if (nums[i - 1] > 0) {
+        list.add(i);
+      }
+    }
+    return list;
+  }
+}
diff --git a/Easy/Maximum 69 Number.java b/Easy/Maximum 69 Number.java
index ae9e7383..a58d97e6 100644
--- a/Easy/Maximum 69 Number.java	
+++ b/Easy/Maximum 69 Number.java	
@@ -1,12 +1,23 @@
 class Solution {
   public int maximum69Number (int num) {
-    char[] chars = String.valueOf(num).toCharArray();
-    for (int i = 0; i < chars.length; i++) {
-      if (chars[i] == '6') {
-        chars[i] = '9';
-        break;
+    int lastSixIndex = Integer.MAX_VALUE;
+    int count = 0;
+    int copy = num;
+    while (copy > 0) {
+      int rem = copy % 10;
+      if (rem == 6) {
+        lastSixIndex = count;
       }
+      copy /= 10;
+      count++;
     }
-    return Integer.parseInt(String.valueOf(chars));
+    if (lastSixIndex == Integer.MAX_VALUE) {
+      return num;
+    }
+    return (
+      ((num / ((int) Math.pow(10, lastSixIndex + 1))) * ((int) Math.pow(10, lastSixIndex + 1))) +
+      (9 * ((int) Math.pow(10, lastSixIndex))) + 
+      (num % ((int) Math.pow(10, lastSixIndex)))
+    );
   }
 }
diff --git a/Easy/Nested List Weight Sum.java b/Easy/Nested List Weight Sum.java
index e5bab7b1..65fe828b 100644
--- a/Easy/Nested List Weight Sum.java	
+++ b/Easy/Nested List Weight Sum.java	
@@ -27,21 +27,29 @@
  * }
  */
 class Solution {
-    int sum;
-    public int depthSum(List<NestedInteger> nestedList) {
-        sum = 0;
-        helper(nestedList, 1);
-        return sum;
+  public int depthSum(List<NestedInteger> nestedList) {
+    int level = 1;
+    Queue<NestedInteger> queue = new LinkedList<>();
+    int sum = 0;
+    for (NestedInteger nestedInteger : nestedList) {
+      queue.add(nestedInteger);
     }
-    
-    private void helper(List<NestedInteger> nestedList, int level) {
-        for (NestedInteger nested : nestedList) {
-            if (nested.isInteger()) {
-                sum += nested.getInteger() * level;
-            }
-            else {
-                helper(nested.getList(), level + 1);
-            }
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        NestedInteger nestedInteger = queue.remove();
+        if (nestedInteger.isInteger()) {
+          sum += nestedInteger.getInteger() * level;
         }
+        else {
+          List<NestedInteger> nList = nestedInteger.getList();
+          for (NestedInteger nInteger : nList) {
+            queue.add(nInteger);
+          }
+        }
+      }
+      level++;
     }
+    return sum;
+  }
 }
diff --git a/Easy/Squares of a Sorted Array.java b/Easy/Squares of a Sorted Array.java
index 65f5c973..efd36968 100644
--- a/Easy/Squares of a Sorted Array.java	
+++ b/Easy/Squares of a Sorted Array.java	
@@ -1,21 +1,35 @@
 class Solution {
-    public int[] sortedSquares(int[] A) {
-        int[] arr = new int[A.length];
-        int start = 0;
-        int end = A.length - 1;
-        int idx = A.length - 1;
-        
-        while (start <= end) {
-            if (Math.abs(A[start]) < Math.abs(A[end])) {
-                arr[idx--] = A[end] * A[end];
-                end--;
-            }
-            else {
-                arr[idx--] = A[start] * A[start];
-                start++;
-            }
+  public int[] sortedSquares(int[] A) {
+    int posIdx = A.length;
+    for (int i = 0; i < A.length; i++) {
+      if (A[i] >= 0) {
+        posIdx = i;
+        break;
+      }
+    }
+    int[] ans = new int[A.length];
+    int negIdx = posIdx - 1;
+    int idx = 0;
+    while (negIdx >= 0 || posIdx < A.length) {
+      if (negIdx >= 0 && (posIdx >= 0 && posIdx < A.length)) {
+        if (A[negIdx] * A[negIdx] > A[posIdx] * A[posIdx]) {
+          ans[idx++] = A[posIdx] * A[posIdx];
+          posIdx++;
+        }
+        else {
+          ans[idx++] = A[negIdx] * A[negIdx];
+          negIdx--;
         }
-        
-        return arr;
+      }
+      else if (negIdx >= 0 && posIdx >= A.length) {
+        ans[idx++] = A[negIdx] * A[negIdx];
+        negIdx--;
+      }
+      else {
+        ans[idx++] = A[posIdx] * A[posIdx];
+        posIdx++;
+      }
     }
+    return ans;
+  }
 }
diff --git a/Medium/Nested List Weight Sum II.java b/Medium/Nested List Weight Sum II.java
index d1ac07d2..c5fcc6e8 100644
--- a/Medium/Nested List Weight Sum II.java	
+++ b/Medium/Nested List Weight Sum II.java	
@@ -27,36 +27,31 @@
  * }
  */
 class Solution {
-    int maxDepth;
-    int sum;
-    public int depthSumInverse(List<NestedInteger> nestedList) {
-        maxDepth = 0;
-        maxDepthHelper(nestedList, 1);
-        
-        sum = 0;
-        helper(nestedList, maxDepth);
-        
-        return sum;
+  public int depthSumInverse(List<NestedInteger> nestedList) {
+    Queue<NestedInteger> queue = new LinkedList<>();
+    int prevSum = 0;
+    int currSum = 0;
+    for (NestedInteger nestedInteger : nestedList) {
+      queue.add(nestedInteger);
     }
-    
-    private void helper(List<NestedInteger> nestedList, int level) {
-        for (NestedInteger nested : nestedList) {
-            if (nested.isInteger()) {
-                sum += nested.getInteger() * level;
-            }
-            else {
-                helper(nested.getList(), level - 1);
-            }
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      int levelSum = 0;
+      while (size-- > 0) {
+        NestedInteger removed = queue.remove();
+        if (removed.isInteger()) {
+          levelSum += removed.getInteger();
         }
-    }
-    
-    private void maxDepthHelper(List<NestedInteger> nestedList, int currLevel) {
-        maxDepth = Math.max(maxDepth, currLevel);
-        
-        for (NestedInteger nestedInteger : nestedList) {
-            if (!nestedInteger.isInteger()) {
-                maxDepthHelper(nestedInteger.getList(), currLevel + 1);
-            }
+        else {
+          List<NestedInteger> nList = removed.getList();
+          for (NestedInteger nInteger : nList) {
+            queue.add(nInteger);
+          }
         }
+      }
+      prevSum += levelSum;
+      currSum += prevSum;
     }
+    return currSum;
+  }
 }

From 7a7f0136b2e8e026fe0315c3d0c73be230dd29c5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 29 Mar 2020 14:05:57 -0700
Subject: [PATCH 0138/2175] Added 4 solutions & modified 2 solution

---
 Easy/Find Lucky Integer in an Array.java      | 14 +++
 .../Serialize and Deserialize N-ary Tree.java | 88 +++++++++----------
 Medium/Count Number of Teams.java             | 19 ++++
 Medium/Daily Temperatures.java                | 25 +++---
 Medium/Design Underground System.java         | 36 ++++++++
 Medium/Prime Palindrome.java                  | 39 ++++++++
 6 files changed, 161 insertions(+), 60 deletions(-)
 create mode 100644 Easy/Find Lucky Integer in an Array.java
 create mode 100644 Medium/Count Number of Teams.java
 create mode 100644 Medium/Design Underground System.java
 create mode 100644 Medium/Prime Palindrome.java

diff --git a/Easy/Find Lucky Integer in an Array.java b/Easy/Find Lucky Integer in an Array.java
new file mode 100644
index 00000000..d5ad2b50
--- /dev/null
+++ b/Easy/Find Lucky Integer in an Array.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int findLucky(int[] arr) {
+    int[] counter = new int[501];
+    for (int num : arr) {
+      counter[num]++;
+    }
+    for (int i = 500; i > 0; i--) {
+      if (counter[i] == i) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}
diff --git a/Hard/Serialize and Deserialize N-ary Tree.java b/Hard/Serialize and Deserialize N-ary Tree.java
index af8a394e..29d46233 100644
--- a/Hard/Serialize and Deserialize N-ary Tree.java	
+++ b/Hard/Serialize and Deserialize N-ary Tree.java	
@@ -6,63 +6,59 @@ class Node {
 
     public Node() {}
 
-    public Node(int _val,List<Node> _children) {
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
         val = _val;
         children = _children;
     }
 };
 */
 class Codec {
-
-    // Encodes a tree to a single string.
-    StringBuilder sb;
-    public String serialize(Node root) {
-        if (root == null) {
-            return "";
-        }
-        
-        sb = new StringBuilder();
-        serializeHelper(root);
-        
-        return sb.toString().substring(0, sb.length() - 1);
-    }
     
-    private void serializeHelper(Node root) {        
-        if (root == null) {
-            return;
-        }
-        
-        sb.append(root.val).append(",").append(root.children.size()).append(",");
-        for (Node child : root.children) {
-            serializeHelper(child);
-        }
+  // Encodes a tree to a single string.
+  private final String SEPARATOR = ",";
+  private final String NULL_SEPARATOR = "#";
+  public String serialize(Node root) {
+    StringBuilder sb = new StringBuilder();
+    serializeHelper(root, sb);
+    return sb.toString();
+  }
+  
+  private void serializeHelper(Node root, StringBuilder sb) {
+    if (root == null) {
+      sb.append(NULL_SEPARATOR).append(SEPARATOR);
+    }
+    else {
+      sb.append(root.val).append(SEPARATOR).append(root.children.size()).append(SEPARATOR);
+      for (Node child : root.children) {
+        serializeHelper(child, sb);
+      }
     }
+  }
 
-    // Decodes your encoded data to tree.
-    public Node deserialize(String data) {
-        if (data == null || data.length() == 0) {
-            return null;
-        }
-        
-        Queue<String> queue = new LinkedList<>();
-        queue.addAll(Arrays.asList(data.split(",")));
-        
-        return deserializeHelper(queue);
+  // Decodes your encoded data to tree.
+  public Node deserialize(String data) {
+    Deque<String> dq = new ArrayDeque<>(Arrays.asList(data.split(SEPARATOR)));
+    return deserializeHelper(dq);
+  }
+  
+  private Node deserializeHelper(Deque<String> dq) {
+    String removed = dq.removeFirst();
+    if (removed.equals(NULL_SEPARATOR)) {
+      return null;
     }
-    
-    private Node deserializeHelper(Queue<String> queue) {
-        Node root = new Node();
-        root.val = Integer.parseInt(queue.remove());
-        int size = Integer.parseInt(queue.remove());
-        
-        root.children = new ArrayList<>(size);
-        
-        for (int i = 0; i < size; i++) {
-            root.children.add(deserializeHelper(queue));
-        }
-        
-        return root;
+    else {
+      Node node = new Node(Integer.parseInt(removed), new ArrayList<>());
+      int childCount = Integer.parseInt(dq.removeFirst());
+      for (int i = 0; i < childCount; i++) {
+        node.children.add(deserializeHelper(dq));
+      }
+      return node;
     }
+  }
 }
 
 // Your Codec object will be instantiated and called as such:
diff --git a/Medium/Count Number of Teams.java b/Medium/Count Number of Teams.java
new file mode 100644
index 00000000..26e0771e
--- /dev/null
+++ b/Medium/Count Number of Teams.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int numTeams(int[] rating) {
+    int res = 0;
+    for (int i = 0; i < rating.length - 1; i++) {
+      int[] less = new int[2];
+      int[] great = new int[2];
+      for (int j = 0; j < rating.length; j++) {
+        if (rating[i] < rating[j]) {
+          less[i > j ? 0 : 1]++;
+        }
+        if (rating[i] > rating[j]) {
+          great[i > j ? 0 : 1]++;
+        }
+      }
+      res += less[0] * great[1] + less[1] * great[0];
+    }
+    return res;
+  } 
+}
diff --git a/Medium/Daily Temperatures.java b/Medium/Daily Temperatures.java
index 2c1f7b91..ce3bdca3 100644
--- a/Medium/Daily Temperatures.java	
+++ b/Medium/Daily Temperatures.java	
@@ -1,17 +1,14 @@
 class Solution {
-    public int[] dailyTemperatures(int[] T) {
-        Stack<Integer> stack = new Stack<>();
-        int[] ans = new int[T.length];
-        
-        for (int i = T.length - 1; i >= 0; i--) {
-            while (!stack.isEmpty() && T[i] >= T[stack.peek()]) {
-                stack.pop();
-            }
-            
-            ans[i] = stack.isEmpty() ? 0 : stack.peek() - i;
-            stack.push(i);
-        }
-        
-        return ans;
+  public int[] dailyTemperatures(int[] T) {
+    Stack<Integer> stack = new Stack<>();
+    int[] ans = new int[T.length];
+    for (int i = T.length - 1; i >= 0; i--) {
+      while (!stack.isEmpty() && T[stack.peek()] <= T[i]) {
+        stack.pop();
+      }
+      ans[i] = stack.isEmpty() ? 0 : (stack.peek() - i);
+      stack.push(i);
     }
+    return ans;
+  }
 }
diff --git a/Medium/Design Underground System.java b/Medium/Design Underground System.java
new file mode 100644
index 00000000..730aaa49
--- /dev/null
+++ b/Medium/Design Underground System.java	
@@ -0,0 +1,36 @@
+class UndergroundSystem {
+  Map<Integer, String> checkInMap;
+  Map<String, Integer> timeMap;
+  Map<String, Integer> countMap;
+  public UndergroundSystem() {
+    checkInMap = new HashMap<>();
+    timeMap = new HashMap<>();
+    countMap = new HashMap<>();
+  }
+
+  public void checkIn(int id, String stationName, int t) {
+    checkInMap.put(id, stationName + "," + t);
+  }
+
+  public void checkOut(int id, String stationName, int t) {
+    String val = checkInMap.get(id);
+    String prevStationName = val.split(",")[0];
+    int prevTime = Integer.parseInt(val.split(",")[1]);
+    String key = prevStationName + "|" + stationName;
+    timeMap.put(key, timeMap.getOrDefault(key, 0) + t - prevTime);
+    countMap.put(key, countMap.getOrDefault(key, 0) + 1);
+  }
+
+  public double getAverageTime(String startStation, String endStation) {
+    String key = startStation + "|" + endStation;
+    return ((double) timeMap.get(key)) / countMap.get(key);
+  }
+}
+
+/**
+ * Your UndergroundSystem object will be instantiated and called as such:
+ * UndergroundSystem obj = new UndergroundSystem();
+ * obj.checkIn(id,stationName,t);
+ * obj.checkOut(id,stationName,t);
+ * double param_3 = obj.getAverageTime(startStation,endStation);
+ */
diff --git a/Medium/Prime Palindrome.java b/Medium/Prime Palindrome.java
new file mode 100644
index 00000000..afb50361
--- /dev/null
+++ b/Medium/Prime Palindrome.java	
@@ -0,0 +1,39 @@
+class Solution {
+  public int primePalindrome(int N) {
+    for (int i = 1; i <= 5; i++) {
+      for (int root = (int)Math.pow(10, i - 1); root < (int)Math.pow(10, i); root++) {
+        StringBuilder sb = new StringBuilder(Integer.toString(root));
+        for (int j = i - 2; j >= 0; j--) {
+          sb.append(sb.charAt(j));
+        }
+        int num = Integer.valueOf(sb.toString());
+        if (num >= N && isPrime(num)) {
+          return num;
+        }
+      }
+      for (int root = (int)Math.pow(10, i - 1); root < (int)Math.pow(10, i); root++) {
+        StringBuilder sb = new StringBuilder(Integer.toString(root));
+        for (int j = i - 1; j >= 0; j--) {
+          sb.append(sb.charAt(j));
+        }
+        int num = Integer.parseInt(sb.toString());
+        if (num >= N && isPrime(num)) {
+          return num;
+        }
+      }
+    }
+    return -1;
+  }
+  
+  private boolean isPrime(int n) {
+    if (n < 2) {
+      return false;
+    }
+    for (int j = 2; j <= (int) Math.sqrt(n); j++) {
+      if (n % j == 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

From d825ceb19a0dba5eb82a36ae5494af7b2116255b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 30 Mar 2020 14:52:56 -0700
Subject: [PATCH 0139/2175] Added 1 solution & modified 1 solution

---
 Medium/Game of Life.java                   | 68 ++++++++++------------
 Medium/Shortest Path in Binary Matrix.java | 34 +++++++++++
 2 files changed, 66 insertions(+), 36 deletions(-)
 create mode 100644 Medium/Shortest Path in Binary Matrix.java

diff --git a/Medium/Game of Life.java b/Medium/Game of Life.java
index 151b60b7..b1cc147d 100644
--- a/Medium/Game of Life.java	
+++ b/Medium/Game of Life.java	
@@ -1,43 +1,39 @@
 class Solution {
-    public void gameOfLife(int[][] board) {
-        for (int i=0; i<board.length; i++) {
-            for (int j=0; j<board[i].length; j++) {
-                int aliveNeighbours = getLiveCount(board, i, j);
-                boolean selfAlive = isAlive(board, i, j);
-                if (selfAlive) {
-                	if (aliveNeighbours < 2 || aliveNeighbours > 3) {
-                		board[i][j] = selfAlive ? 2 : 0;
-                	}
-                }
-                else {
-            		if (aliveNeighbours == 3) {
-            			board[i][j] = selfAlive ? 1 : 3;
-            		}
-            	}
-            }
+  int[][] dirs = {{1, 0}, {0, 1}, {1, 1}, {-1, -1}, {-1, 0}, {0, -1}, {1, -1}, {-1, 1}};
+  public void gameOfLife(int[][] board) {
+    int rows = board.length;
+    int cols = board[0].length;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        int count = getLiveNeighbourCount(board, i, j);
+        if (board[i][j] == 1) {
+          if (count < 2 || count > 3) {
+            board[i][j] = -1;
+          }
         }
-        
-        for (int i=0; i<board.length; i++) {
-            for (int j=0; j<board[i].length; j++) {
-                board[i][j] = board[i][j] == 1 || board[i][j] == 3 ? 1 : 0;
-            }
+        else {
+          if (count == 3) {
+            board[i][j] = 2;
+          }
         }
+      }
     }
-
-    private boolean isAlive(int[][] board, int row, int col) {
-		return row >= 0 && row < board.length && col >= 0 && col < board[0].length && (board[row][col] == 1 || board[row][col] == 2);
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        board[i][j] = board[i][j] > 0 ? 1 : 0;
+      }
     }
-
-    private int getLiveCount(int[][] board, int i, int j) {
-        int liveCount = 0;
-
-        int[][] possibleCoordinates = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}};
-        for (int[] coordinate : possibleCoordinates) {
-        	if (isAlive(board, i + coordinate[0], j + coordinate[1])) {
-        		liveCount++;
-        	}
-        }
-
-        return liveCount;
+  }
+  
+  private int getLiveNeighbourCount(int[][] board, int x, int y) {
+    int count = 0;
+    for (int[] dir : dirs) {
+      int newX = x + dir[0];
+      int newY = y + dir[1];
+      if (newX >= 0 && newX < board.length && newY >= 0 && newY < board[0].length && Math.abs(board[newX][newY]) == 1) {
+        count++;
+      }
     }
+    return count;
+  }
 }
diff --git a/Medium/Shortest Path in Binary Matrix.java b/Medium/Shortest Path in Binary Matrix.java
new file mode 100644
index 00000000..d73302d5
--- /dev/null
+++ b/Medium/Shortest Path in Binary Matrix.java	
@@ -0,0 +1,34 @@
+class Solution {
+  int[][] dirs = {{0,1},{0,-1},{1,0},{-1,0},{1,-1},{-1,1},{-1,-1},{1,1}};
+  public int shortestPathBinaryMatrix(int[][] grid) {
+    int rows = grid.length;
+    int cols = grid[0].length;
+    if (grid[0][0] == 1 || grid[rows - 1][cols - 1] == 1) {
+      return -1;
+    }
+    boolean[][] visited = new boolean[rows][cols];
+    Queue<int[]> queue = new LinkedList<>();
+    queue.add(new int[]{0, 0});
+    visited[0][0] = true;
+    int steps = 0;
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int[] removed = queue.remove();
+        if (removed[0] == (rows - 1) && removed[1] == (cols - 1)) {
+          return steps + 1;
+        }
+        for (int i = 0; i < dirs.length; i++) {
+          int newX = removed[0] + dirs[i][0];
+          int newY = removed[1] + dirs[i][1];
+          if (newX >= 0 && newX < rows && newY >= 0 && newY < cols && !visited[newX][newY] && grid[newX][newY] == 0) {
+            queue.add(new int[]{newX, newY});
+            visited[newX][newY] = true;
+          }
+        }
+      }
+      steps++;
+    }
+    return -1;
+  }
+}

From 76cda3a9f2ba76f5a8366e7c435dd55e5ca4fc74 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 1 Apr 2020 18:04:48 -0700
Subject: [PATCH 0140/2175] Modified 2 solutions

---
 Easy/Sentence Similarity.java | 38 +++++++++++++++++------------------
 Easy/Single-Row Keyboard.java | 27 ++++++++++++-------------
 2 files changed, 31 insertions(+), 34 deletions(-)

diff --git a/Easy/Sentence Similarity.java b/Easy/Sentence Similarity.java
index e2293433..7e779bfe 100644
--- a/Easy/Sentence Similarity.java	
+++ b/Easy/Sentence Similarity.java	
@@ -1,23 +1,21 @@
 class Solution {
-    public boolean areSentencesSimilar(String[] words1, String[] words2, String[][] pairs) {
-        if (words1.length != words2.length) return false;
-        
-        Map<String, HashSet<String>> map = new HashMap<>();
-        
-        for (String[] p: pairs) {
-            if (!map.containsKey(p[0])) {
-                map.put(p[0], new HashSet<>());
-            }
-            map.get(p[0]).add(p[1]);
-        }
-        
-        for (int i=0;i<words1.length;i++) {
-            if (!((words1[i].equals(words2[i])) || (map.containsKey(words1[i]) && map.get(words1[i]).contains(words2[i])) ||
-                 (map.containsKey(words2[i]) && map.get(words2[i]).contains(words1[i])))) {
-                return false;
-            }
-        }
-        
-        return true;
+  public boolean areSentencesSimilar(String[] words1, String[] words2, List<List<String>> pairs) {
+    if (words1.length != words2.length) {
+      return false;
     }
+    Set<String> set = new HashSet<>();
+    for (List<String> pair : pairs) {
+      String word1 = pair.get(0);
+      String word2 = pair.get(1);
+      set.add(word1 + "|" + word2);
+    }
+    for (int i = 0; i < words1.length; i++) {
+      String word1 = words1[i];
+      String word2 = words2[i];
+      if (!(word1.equals(word2) || set.contains(word1 + "|" + word2) || set.contains(word2 + "|" + word1))) {
+        return false;
+      }
+    }
+    return true;
+  }
 }
diff --git a/Easy/Single-Row Keyboard.java b/Easy/Single-Row Keyboard.java
index c290c5f3..5a59a1d6 100644
--- a/Easy/Single-Row Keyboard.java	
+++ b/Easy/Single-Row Keyboard.java	
@@ -1,17 +1,16 @@
 class Solution {
-    public int calculateTime(String keyboard, String word) {
-        Map<Character, Integer> map = new HashMap<>();
-        for (int i = 0; i < keyboard.length(); i++) {
-            map.put(keyboard.charAt(i), i);
-        }
-        
-        int currPos = 0;
-        int totalTime = 0;
-        for (char c : word.toCharArray()) {
-            totalTime += Math.abs(currPos - map.get(c));
-            currPos = map.get(c);
-        }
-        
-        return totalTime;
+  public int calculateTime(String keyboard, String word) {
+    Map<Character, Integer> map = new HashMap<>();
+    int pos = 0;
+    for (char c : keyboard.toCharArray()) {
+      map.put(c, pos++);
     }
+    int total = 0;
+    int currPos = 0;
+    for (char c : word.toCharArray()) {
+      total += Math.abs(currPos - map.get(c));
+      currPos = map.get(c);
+    }
+    return total;
+  }
 }

From 19a391e6f1f2e9cd1e8d0e5c433b6997736bcbc2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 2 Apr 2020 18:48:22 -0700
Subject: [PATCH 0141/2175] Modified 3 solutions

---
 Easy/Happy Number.java             | 44 +++++++-------
 Medium/Friend Circles.java         | 72 +++++++++++------------
 Medium/Sentence Similarity II.java | 93 ++++++++++++------------------
 3 files changed, 94 insertions(+), 115 deletions(-)

diff --git a/Easy/Happy Number.java b/Easy/Happy Number.java
index e74791e6..13adce96 100644
--- a/Easy/Happy Number.java	
+++ b/Easy/Happy Number.java	
@@ -1,27 +1,27 @@
 class Solution {
-    public boolean isHappy(int n) {
-        Set<Integer> set = new HashSet<>();
-        
-        while (n != 1) {
-            int sumOfDigitSquare = getSumOfDigitSquare(n);
-            if (set.contains(sumOfDigitSquare)) {
-                return false;
-            }
-            
-            set.add(sumOfDigitSquare);
-            n = sumOfDigitSquare;
-        }
-        
+  public boolean isHappy(int n) {
+    Set<Integer> set = new HashSet<>();
+    set.add(n);
+    while (true) {
+      int sumOfDigitSquare = getSumOfDigitSquare(n);
+      if (sumOfDigitSquare == 1) {
         return true;
+      }
+      if (set.contains(sumOfDigitSquare)) {
+        break;
+      }
+      set.add(sumOfDigitSquare);
+      n = sumOfDigitSquare;
     }
-    
-    private int getSumOfDigitSquare(int n) {
-        int sum = 0;
-        while (n > 0) {
-            sum += Math.pow(n % 10, 2);
-            n /= 10;
-        }
-        
-        return sum;
+    return false;
+  }
+  
+  private int getSumOfDigitSquare(int n) {
+    int sum = 0;
+    while (n > 0) {
+      sum += (int) Math.pow(n % 10, 2);
+      n /= 10;
     }
+    return sum;
+  }
 }
diff --git a/Medium/Friend Circles.java b/Medium/Friend Circles.java
index 4a1d3bbd..2ceb3c46 100644
--- a/Medium/Friend Circles.java	
+++ b/Medium/Friend Circles.java	
@@ -1,44 +1,40 @@
 class Solution {
-    public int findCircleNum(int[][] M) {
-        Map<Integer, Set<Integer>> map = new HashMap<>();
-        for (int i = 0; i < M.length; i++) {
-            for (int j = 0; j < M.length; j++) {
-                if (M[i][j] == 1) {
-                    map.computeIfAbsent(i, k -> new HashSet<>()).add(j);
-                }
-            }
-        }
-        
-        return dfs(map, M.length);
+  public int findCircleNum(int[][] M) {
+    Map<Integer, Set<Integer>> map = new HashMap<>();
+    for (int i = 0; i < M.length; i++) {
+      for (int j = 0; j < M[i].length; j++) {
+        if (M[i][j] == 1) {
+          map.computeIfAbsent(i, k -> new HashSet<>()).add(j);
+        } 
+      }
     }
-    
-    private int dfs(Map<Integer, Set<Integer>> map, int n) {
-        int count = 0;
-        Set<Integer> seen = new HashSet<>();
-        
-        for (int i = 0; i < n; i++) {
-            if (!seen.contains(i)) {
-                dfsHelper(i, seen, map);
-                count++;
-            }
-        }
-        
-        return count;
+    return dfs(map, M.length);
+  }
+  
+  private int dfs(Map<Integer, Set<Integer>> map, int n) {
+    int count = 0;
+    Set<Integer> seen = new HashSet<>();
+    for (int i = 0; i < n; i++) {
+      if (!seen.contains(i)) {
+        dfsHelper(map, i, seen);
+        count++;
+      }
     }
-    
-    private void dfsHelper(int idx, Set<Integer> seen, Map<Integer, Set<Integer>> map) {
-        Queue<Integer> queue = new LinkedList<>();
-        queue.add(idx);
-        
-        while (!queue.isEmpty()) {
-            int removed = queue.remove();
-            seen.add(removed);
-            
-            for (int friend : map.getOrDefault(removed, new HashSet<>())) {
-                if (!seen.contains(friend)) {
-                    queue.add(friend);
-                }
-            }
+    return count;
+  }
+  
+  private void dfsHelper(Map<Integer, Set<Integer>> map, int curr, Set<Integer> seen) {
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(curr);
+    seen.add(curr);
+    while (!queue.isEmpty()) {
+      int removed = queue.remove();
+      for (Integer friend : map.getOrDefault(removed, new HashSet<>())) {
+        if (!seen.contains(friend)) {
+          queue.add(friend);
+          seen.add(friend);
         }
+      }
     }
+  }
 }
diff --git a/Medium/Sentence Similarity II.java b/Medium/Sentence Similarity II.java
index 7ec66eaa..cda4a674 100644
--- a/Medium/Sentence Similarity II.java	
+++ b/Medium/Sentence Similarity II.java	
@@ -1,60 +1,43 @@
 class Solution {
-    public boolean areSentencesSimilarTwo(String[] words1, String[] words2, List<List<String>> pairs) {
-        Map<String, Set<String>> map = new HashMap<>();
-
-        for (List<String> pair : pairs) {
-            String word1 = pair.get(0);
-            String word2 = pair.get(1);
-
-            map.computeIfAbsent(word1, k -> new HashSet<String>()).add(word2);
-            map.computeIfAbsent(word2, k -> new HashSet<String>()).add(word1);
-        }
-
-        int idx1 = 0;
-        int idx2 = 0;
-
-        while (idx1 < words1.length && idx2 < words2.length) {
-            if (words1[idx1].equals(words2[idx2])) {
-                idx1++;
-                idx2++;
-                continue;
-            }
-
-            if (!dfs(map, words1[idx1], words2[idx2])) {
-                return false;
-            }
-
-            idx1++;
-            idx2++;
-        }
-
-        return idx1 == words1.length && idx2 == words2.length;
+  public boolean areSentencesSimilarTwo(String[] words1, String[] words2, List<List<String>> pairs) {
+    if (words1.length != words2.length) {
+      return false;
     }
-
-    private boolean dfs(Map<String, Set<String>> map, String s, String t) {
-        Stack<String> stack = new Stack<>();
-        Set<String> visited = new HashSet<>();
-
-        stack.push(s);
-        visited.add(s);
-
-        while (!stack.isEmpty()) {
-            String word = stack.pop();
-            if (word.equals(t)) {
-                return true;
-            }
-            if (map.containsKey(word)) {
-                Iterator<String> iterator = map.get(word).iterator();
-                while (iterator.hasNext()) {
-                    String temp = iterator.next();
-                    if (!visited.contains(temp)) {
-                        stack.push(temp);
-                        visited.add(temp);
-                    }
-                }
-            }
-        }
-
+    Map<String, Set<String>> map = new HashMap<>();
+    for (List<String> pair : pairs) {
+      String word1 = pair.get(0);
+      String word2 = pair.get(1);
+      map.computeIfAbsent(word1, k -> new HashSet<>()).add(word2);
+      map.computeIfAbsent(word2, k -> new HashSet<>()).add(word1);
+    }
+    
+    for (int i = 0; i < words1.length; i++) {
+      String start = words1[i];
+      String end = words2[i];
+      if (!dfs(map, start, end)) {
         return false;
+      }
+    }
+    return true;
+  }
+  
+  private boolean dfs(Map<String, Set<String>> map, String start, String end) {
+    Queue<String> queue = new LinkedList<>();
+    Set<String> set = new HashSet<>();
+    queue.add(start);
+    set.add(start);
+    while (!queue.isEmpty()) {
+      String removed = queue.remove();
+      if (removed.equals(end)) {
+        return true;
+      }
+      for (String similar : map.getOrDefault(removed, new HashSet<>())) {
+        if (!set.contains(similar)) {
+          queue.add(similar);
+          set.add(similar);
+        }
+      }
     }
+    return false;
+  }
 }

From 6e9ac67e8d49b92cfb13057bbac29724e9fef280 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 3 Apr 2020 11:51:36 -0700
Subject: [PATCH 0142/2175] Modified 3 solutions

---
 Easy/Island Perimeter.java | 59 +++++++++-----------------------
 Easy/Maximum Subarray.java | 27 ++++++---------
 Medium/Accounts Merge.java | 70 ++++++++++++++++++--------------------
 3 files changed, 60 insertions(+), 96 deletions(-)

diff --git a/Easy/Island Perimeter.java b/Easy/Island Perimeter.java
index 6d21edc1..fbf4ac41 100644
--- a/Easy/Island Perimeter.java	
+++ b/Easy/Island Perimeter.java	
@@ -1,47 +1,20 @@
 class Solution {
-    public int islandPerimeter(int[][] grid) {
-        int n = grid.length;
-        int m = grid[0].length;
-        
-        int p = 0;
-        for (int i=0;i<n;i++) {
-            for (int j=0;j<m;j++) {
-                if (grid[i][j] == 1) {
-                    if (i-1 >= 0) {
-                        if (grid[i-1][j] == 0) {
-                            p++;
-                        }
-                    }
-                    else {
-                        p++;
-                    }
-                    if (i+1 < n) {
-                        if (grid[i+1][j] == 0) {
-                            p++;
-                        }
-                    }
-                    else {
-                        p++;
-                    }
-                    if (j-1 >= 0) {
-                        if (grid[i][j-1] == 0) {
-                            p++;
-                        }
-                    }
-                    else {
-                        p++;
-                    }
-                    if (j+1 < m) {
-                        if (grid[i][j+1] == 0) {
-                            p++;
-                        }
-                    }
-                    else {
-                        p++;
-                    }
-                }
-            }
+  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public int islandPerimeter(int[][] grid) {
+    int sum = 0;
+    for (int i = 0; i < grid.length; i++) {
+      for (int j = 0; j < grid[0].length; j++) {
+        if (grid[i][j] == 1) {
+          for (int[] dir : dirs) {
+            sum += isBoundary(grid, i + dir[0], j + dir[1]) ? 1 : 0;
+          }
         }
-        return p;
+      }
     }
+    return sum;
+  }
+  
+  private boolean isBoundary(int[][] grid, int x, int y) {
+    return x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] == 0;
+  }
 }
diff --git a/Easy/Maximum Subarray.java b/Easy/Maximum Subarray.java
index e6b70103..0c3667dd 100644
--- a/Easy/Maximum Subarray.java	
+++ b/Easy/Maximum Subarray.java	
@@ -1,19 +1,14 @@
 class Solution {
-    public int maxSubArray(int[] nums) {
-        int max = Integer.MIN_VALUE;
-        int sum = 0;
-        for (int i=0;i<nums.length;i++) {
-            if (sum < 0) {
-                sum = nums[i];
-            }
-            else {
-                sum += nums[i];
-            }
-            
-            if (sum > max) {
-                max = sum;
-            }
-        }
-        return max;
+  public int maxSubArray(int[] nums) {
+    if (nums.length == 0) {
+      return 0;
     }
+    int currSum = nums[0];
+    int maxSum = currSum;
+    for (int i = 1; i < nums.length; i++) {
+      currSum = Math.max(currSum + nums[i], nums[i]);
+      maxSum = Math.max(maxSum, currSum);
+    }
+    return maxSum;
+  }
 }
diff --git a/Medium/Accounts Merge.java b/Medium/Accounts Merge.java
index 0170b23c..caa718e8 100644
--- a/Medium/Accounts Merge.java	
+++ b/Medium/Accounts Merge.java	
@@ -1,42 +1,38 @@
 class Solution {
-    public List<List<String>> accountsMerge(List<List<String>> accounts) {
-        Map<String, String> emailToName = new HashMap<>();
-        Map<String, List<String>> graph = new HashMap<>();
-        
-        for (List<String> account : accounts) {
-            String name = account.get(0);
-            
-            for (int i = 1; i < account.size(); i++) {
-                graph.computeIfAbsent(account.get(i), k -> new ArrayList<>()).add(account.get(1));
-                graph.computeIfAbsent(account.get(1), k -> new ArrayList<>()).add(account.get(i));
-                emailToName.put(account.get(i), name);
-            }
-        }
-        
-        Set<String> visited = new HashSet<>();
-        List<List<String>> mergedAccounts = new ArrayList<>();
-        for (String email : graph.keySet()) {
-            if (!visited.contains(email)) {
-                visited.add(email);
-                Stack<String> stack = new Stack<>();
-                stack.push(email);
-                List<String> singleAccount = new ArrayList<>();
-                while (!stack.isEmpty()) {
-                    String removed = stack.pop();
-                    singleAccount.add(removed);
-                    for (String connected : graph.get(removed)) {
-                        if (!visited.contains(connected)) {
-                            visited.add(connected);
-                            stack.push(connected);
-                        }
-                    }
-                }
-                Collections.sort(singleAccount);
-                singleAccount.add(0, emailToName.get(email));
-                mergedAccounts.add(singleAccount);
+  public List<List<String>> accountsMerge(List<List<String>> accounts) {
+    Map<String, String> emailToNameMap = new HashMap<>();
+    Map<String, Set<String>> graph = new HashMap<>();
+    for (List<String> account : accounts) {
+      String name = account.get(0);
+      for (int i = 1; i < account.size(); i++) {
+        emailToNameMap.put(account.get(i), name);
+        graph.computeIfAbsent(account.get(i), k -> new HashSet<>()).add(account.get(1));
+        graph.computeIfAbsent(account.get(1), k -> new HashSet<>()).add(account.get(i));
+      }
+    }
+    Set<String> seen = new HashSet<>();
+    List<List<String>> ans = new ArrayList<>();
+    for (String email : graph.keySet()) {
+      if (!seen.contains(email)) {
+        seen.add(email);
+        Stack<String> stack = new Stack<>();
+        stack.push(email);
+        List<String> component = new ArrayList<>();
+        while (!stack.isEmpty()) {
+          String node = stack.pop();
+          component.add(node);
+          for (String neighbour : graph.get(node)) {
+            if (!seen.contains(neighbour)) {
+              seen.add(neighbour);
+              stack.push(neighbour);
             }
+          }
         }
-        
-        return mergedAccounts;
+        Collections.sort(component);
+        component.add(0, emailToNameMap.get(email));
+        ans.add(component);
+      }
     }
+    return ans;
+  }
 }

From d54aebe0e64f9d1d80800effca105330189277d1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 3 Apr 2020 15:06:38 -0700
Subject: [PATCH 0143/2175] Added Remove Outermost Parentheses.java

---
 Easy/Remove Outermost Parentheses.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Remove Outermost Parentheses.java

diff --git a/Easy/Remove Outermost Parentheses.java b/Easy/Remove Outermost Parentheses.java
new file mode 100644
index 00000000..1eef6edb
--- /dev/null
+++ b/Easy/Remove Outermost Parentheses.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public String removeOuterParentheses(String S) {
+    Stack<Character> stack = new Stack<>();
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < S.length(); i++) {
+      char c = S.charAt(i);
+      if (stack.isEmpty() && c == '(') {
+        stack.push(c);
+        continue;
+      }
+      if (stack.size() == 1 && c == ')') {
+        stack.pop();
+        continue;
+      }
+      if (c == '(') {
+        stack.push(c);
+      }
+      else {
+        stack.pop();
+      }
+      sb.append(c);
+    }
+    return sb.toString();
+  }
+}

From b8fd4f9ee0113e4b545a8cad83986be3f2e3b8e9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 4 Apr 2020 16:28:37 -0700
Subject: [PATCH 0144/2175] Modified 1 solution

---
 Easy/Move Zeroes.java | 17 +++++++++++++++++
 Easy/move_zeroes.java | 29 -----------------------------
 2 files changed, 17 insertions(+), 29 deletions(-)
 create mode 100644 Easy/Move Zeroes.java
 delete mode 100644 Easy/move_zeroes.java

diff --git a/Easy/Move Zeroes.java b/Easy/Move Zeroes.java
new file mode 100644
index 00000000..0406592c
--- /dev/null
+++ b/Easy/Move Zeroes.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public void moveZeroes(int[] nums) {
+    int fast = 0;
+    int slow = 0;
+    int n = nums.length;
+    while (fast < n) {
+      if (nums[fast] != 0) {
+        nums[slow] = nums[fast];
+        slow++;
+      }
+      fast++;
+    }
+    while (slow < n) {
+      nums[slow++] = 0;
+    }
+  }
+}
diff --git a/Easy/move_zeroes.java b/Easy/move_zeroes.java
deleted file mode 100644
index 25a35ecd..00000000
--- a/Easy/move_zeroes.java
+++ /dev/null
@@ -1,29 +0,0 @@
-public class Main {
-    static void moveZeroes(int[] nums) 
-    {
-        int n =nums.length;
-        int[] ans=new int[n];
-        int count=0;
-        int k=0;
-        for(int i=0;i<n;i++)
-        {
-            if(nums[i]!=0)
-            {
-                ans[k]=nums[i];
-                k++;
-                count++;
-            }
-        }
-        
-        count++;
-        while(count<n)
-        {
-            ans[count]=0;
-            count++;
-        }
-        for(int i=0;i<n;i++)
-        {
-            nums[i]=ans[i];
-        }
-        
-    }
\ No newline at end of file

From 35799df99ea2610ed1173e3a73a26f2b282944e7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 5 Apr 2020 18:00:51 -0700
Subject: [PATCH 0145/2175] Added 2 solutions & modified 1 solution

---
 Easy/Best time to buy & sell a stock II.java | 26 ++++----
 Easy/Count Largest Group.java                | 30 +++++++++
 Medium/Delete Leaves With a Given Value.java | 67 ++++++++++++++++++++
 3 files changed, 110 insertions(+), 13 deletions(-)
 create mode 100644 Easy/Count Largest Group.java
 create mode 100644 Medium/Delete Leaves With a Given Value.java

diff --git a/Easy/Best time to buy & sell a stock II.java b/Easy/Best time to buy & sell a stock II.java
index a175bce0..cfe8e938 100644
--- a/Easy/Best time to buy & sell a stock II.java	
+++ b/Easy/Best time to buy & sell a stock II.java	
@@ -1,16 +1,16 @@
 class Solution {
-    public int maxProfit(int[] prices) {
-        int currMin = Integer.MAX_VALUE;
-        int profit = 0;
-        
-        for (int price : prices) {
-            if (price > currMin) {
-                profit += price - currMin;
-            }        
-            
-            currMin = price;
-        }
-        
-        return profit;
+  public int maxProfit(int[] prices) {
+    int lowest = Integer.MAX_VALUE;
+    int profit = 0;
+    for (int i = 0; i < prices.length; i++) {
+      if (prices[i] > lowest) {
+        profit += prices[i] - lowest;
+        lowest = prices[i];
+      }
+      else {
+        lowest = prices[i];
+      }
     }
+    return profit;
+  }
 }
diff --git a/Easy/Count Largest Group.java b/Easy/Count Largest Group.java
new file mode 100644
index 00000000..d009c400
--- /dev/null
+++ b/Easy/Count Largest Group.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public int countLargestGroup(int n) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 1; i <= n; i++) {
+      int digitSum = getDigitSum(i);
+      map.put(digitSum, map.getOrDefault(digitSum, 0) + 1);
+    }
+    int maxCount = 0;
+    int size = 0;
+    for (Integer key : map.keySet()) {
+      if (maxCount < map.get(key)) {
+        maxCount = map.get(key);
+        size = 1;
+      }
+      else if (maxCount == map.get(key)) {
+        size++;
+      }
+    }
+    return size;
+  }
+  
+  private int getDigitSum(int n) {
+    int sum = 0;
+    while (n > 0) {
+      sum += n % 10;
+      n /= 10;
+    }
+    return sum;
+  }
+}
diff --git a/Medium/Delete Leaves With a Given Value.java b/Medium/Delete Leaves With a Given Value.java
new file mode 100644
index 00000000..6d55f07c
--- /dev/null
+++ b/Medium/Delete Leaves With a Given Value.java	
@@ -0,0 +1,67 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+  Map<TreeNode, TreeNode> map;  // A Node-Parent map
+  public TreeNode removeLeafNodes(TreeNode root, int target) {
+    map = new HashMap<>();
+    updateParentMap(root, null);
+    deleteLeaf(root, target);
+    return map.get(root) != null ? null : root;
+  }
+
+  public TreeNode removeLeafNodesRecursive(TreeNode root, int target) {
+    if (root.left != null) {
+      root.left = removeLeafNodes(root.left, target);
+    }
+    if (root.right != null) {
+      root.right = removeLeafNodes(root.right, target);
+    }
+    return root.left == root.right && root.val == target ? null : root;
+  }
+  
+  private void updateParentMap(TreeNode curr, TreeNode parent) {
+    if (curr == null) {
+      return;
+    }
+    map.put(curr, parent);
+    updateParentMap(curr.left, curr);
+    updateParentMap(curr.right, curr);
+  }
+  
+  private void deleteLeaf(TreeNode curr, int target) {
+    if (curr == null) {
+      return;
+    }
+    if (curr.left == null && curr.right == null) {
+      if (curr.val == target) {
+        TreeNode parent = map.get(curr);
+        if (parent == null) {  // If parent is null then mark the parent as -1
+          map.put(curr, new TreeNode(-1));
+          return;
+        }
+        // Else delete the node
+        if (parent.left == curr) {
+          parent.left = null;
+        }
+        else {
+          parent.right = null;
+        }
+        // If parent is leaf with target value then call recursion on parent
+        if (parent.left == null && parent.right == null && parent.val == target) {
+          deleteLeaf(parent, target);
+        }
+      }
+    }
+    else {
+      deleteLeaf(curr.left, target);
+      deleteLeaf(curr.right, target);
+    }
+  }
+}

From 0a28bb032b9c5ba6b3ab358eda49f95579871e44 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 6 Apr 2020 12:06:16 -0700
Subject: [PATCH 0146/2175] Modified 4 solutions

---
 ...mmon Ancestor of a Binary Search Tree.java | 27 +++---
 Medium/Compare Version Numbers.java           | 64 ++++++-------
 Medium/Group Anagrams.java                    | 18 ++--
 Medium/Multiply Strings.java                  | 96 +++++++------------
 4 files changed, 84 insertions(+), 121 deletions(-)

diff --git a/Easy/Lowest Common Ancestor of a Binary Search Tree.java b/Easy/Lowest Common Ancestor of a Binary Search Tree.java
index cc700bd2..aba618f7 100644
--- a/Easy/Lowest Common Ancestor of a Binary Search Tree.java	
+++ b/Easy/Lowest Common Ancestor of a Binary Search Tree.java	
@@ -8,16 +8,21 @@
  * }
  */
 class Solution {
-    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-        
-        if (root.val < p.val && root.val < q.val) {
-            return lowestCommonAncestor(root.right, p, q); 
-        }
-        else if (root.val > p.val && root.val > q.val) {
-            return lowestCommonAncestor(root.left, p, q); 
-        }
-        else {
-            return root;
-        }
+  public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null || p == null || q == null) {
+      return null;
     }
+    if (root == p || root == q) {
+      return root;
+    }
+    if ((root.val > p.val && root.val < q.val) || (root.val < p.val && root.val > q.val)) {
+      return root;
+    }
+    if (root.val > p.val && root.val > q.val) {
+      return lowestCommonAncestor(root.left, p, q);
+    }
+    else {
+      return lowestCommonAncestor(root.right, p, q);
+    }
+  }
 }
diff --git a/Medium/Compare Version Numbers.java b/Medium/Compare Version Numbers.java
index e2b72daf..f41cecb0 100644
--- a/Medium/Compare Version Numbers.java	
+++ b/Medium/Compare Version Numbers.java	
@@ -1,41 +1,31 @@
 class Solution {
-    public static int compareVersion(String version1, String version2) {
-        String[] v1 = version1.split("\\.");
-        String[] v2 = version2.split("\\.");
-
-        int v1Start = 0;
-        int v2Start = 0;
-
-        while (v1Start < v1.length || v2Start < v2.length) {
-
-            if (v1Start < v1.length && v2Start < v2.length) {
-                if (Integer.parseInt(v1[v1Start]) < Integer.parseInt(v2[v2Start])) {
-                    return -1;
-                } else if (Integer.parseInt(v1[v1Start]) > Integer.parseInt(v2[v2Start])) {
-                    return 1;
-                }
-
-                v1Start++;
-                v2Start++;
-            }
-            else if (v1Start < v1.length && v2Start == v2.length) {
-                if (Integer.parseInt(v1[v1Start]) > 0) {
-                    return 1;
-                }
-                else {
-                    v1Start++;
-                }
-            }
-            else {
-                if (Integer.parseInt(v2[v2Start]) > 0) {
-                    return -1;
-                }
-                else {
-                    v2Start++;
-                }
-            }
+  public int compareVersion(String version1, String version2) {
+    String[] versionSplit1 = version1.split("\\.");
+    String[] versionSplit2 = version2.split("\\.");
+    int idx1 = 0;
+    int idx2 = 0;
+    while (idx1 < versionSplit1.length || idx2 < versionSplit2.length) {
+      if (idx1 < versionSplit1.length && idx2 < versionSplit2.length) {
+        int ver1 = Integer.parseInt(versionSplit1[idx1++]);
+        int ver2 = Integer.parseInt(versionSplit2[idx2++]);
+        int c = ver1 - ver2;
+        if (c != 0) {
+          return c > 0 ? 1 : -1;
         }
-
-        return 0;
+      }
+      else if (idx1 < versionSplit1.length || idx2 == versionSplit2.length) {
+        int ver1 = Integer.parseInt(versionSplit1[idx1++]);
+        if (ver1 != 0) {
+          return 1;
+        }
+      }
+      else {
+        int ver2 = Integer.parseInt(versionSplit2[idx2++]);
+        if (ver2 != 0) {
+          return -1;
+        }
+      }
     }
+    return 0;
+  } 
 }
diff --git a/Medium/Group Anagrams.java b/Medium/Group Anagrams.java
index dcdac935..3ce07c65 100644
--- a/Medium/Group Anagrams.java	
+++ b/Medium/Group Anagrams.java	
@@ -2,18 +2,18 @@ class Solution {
   public List<List<String>> groupAnagrams(String[] strs) {
     Map<String, List<String>> map = new HashMap<>();
     for (String str : strs) {
-      map.computeIfAbsent(sortedStr(str), k -> new ArrayList<>()).add(str);
-    }
-    List<List<String>> ans = new ArrayList<>();
-    for (String key : map.keySet()) {
-      ans.add(map.get(key));
+      String key = getKey(str);
+      map.computeIfAbsent(key, k -> new ArrayList<>()).add(str);
     }
+    List<List<String>> ans = new ArrayList<>(map.values());
     return ans;
   }
   
-  private String sortedStr(String s) {
-    char[] chars = s.toCharArray();
-    Arrays.sort(chars);
-    return String.valueOf(chars);
+  private String getKey(String s) {
+    int[] counter = new int[26];
+    for (char c : s.toCharArray()) {
+      counter[c - 'a']++;
+    }
+    return Arrays.toString(counter);
   }
 }
diff --git a/Medium/Multiply Strings.java b/Medium/Multiply Strings.java
index 27238d18..9469b6cd 100644
--- a/Medium/Multiply Strings.java	
+++ b/Medium/Multiply Strings.java	
@@ -1,68 +1,36 @@
 class Solution {
-    public String multiply(String num1, String num2) {
-        // Initial array of n * m size
-        int n = num1.length();
-        int m = num2.length();
-        int[] ans = new int[n + m];
-        
-        // Multiple both strings from end and store it in the array
-        // Keep decreasing end size by one for each iteration
-        int idx = ans.length - 1;
-        int carry = 0;
-        int tempIdx = idx;
-        
-        for (int i = n - 1; i >= 0; i--) {
-            tempIdx = idx;
-            for (int j = m - 1; j >= 0; j--) {
-                char a = num1.charAt(i);
-                char b = num2.charAt(j);
-                
-                int mul = ans[tempIdx] + multiplyChars(a, b) + carry;
-                if (mul > 9) {
-                    carry = mul / 10;
-                    mul = mul % 10;
-                }
-                else {
-                    carry = 0;
-                }
-                
-                ans[tempIdx] = mul;
-                tempIdx--;
-            }
-            
-            // Continue adding carry if present else reset carry
-            while (carry > 0) {
-                int mul = ans[tempIdx] + carry;
-                if (mul > 9) {
-                    carry = mul / 10;
-                    mul = mul % 10;
-                }
-                else {
-                    carry = 0;
-                }
-                
-                ans[tempIdx--] = mul;
-            }
-            
-            idx--;
-        }
-        
-        // Remove initial zeros
-        int zeroIdx = 0;
-        while (zeroIdx < ans.length && ans[zeroIdx] == 0 ) {
-            zeroIdx++;
-        }
-        
-        // Convert array to string and return
-        StringBuilder sb = new StringBuilder();
-        for (int i = zeroIdx; i < ans.length; i++) {
-            sb.append(ans[i]);
-        }
-        
-        return sb.length() == 0 ? "0" : sb.toString();
+  public String multiply(String num1, String num2) {
+    int m = num1.length();
+    int n = num2.length();
+    int[] ans = new int[m + n];
+    int idx = ans.length - 1;
+    for (int i = num1.length() - 1; i >= 0; i--) {
+      int currIdx = idx;
+      int carry = 0;
+      for (int j = num2.length() - 1; j >= 0; j--) {
+        int temp = (
+          ans[currIdx] + Character.getNumericValue(num1.charAt(i)) * Character.getNumericValue(num2.charAt(j)) + carry
+        );
+        carry = temp > 9 ? temp / 10 : 0;
+        temp = temp > 9 ? temp % 10 : temp;
+        ans[currIdx--] = temp;
+      }
+      while (carry > 0) {
+        int temp = ans[currIdx] + carry;
+        carry = temp > 9 ? temp / 10 : 0;
+        temp = temp > 9 ? temp % 10 : temp;
+        ans[currIdx--] = temp;
+      }
+      idx--;
     }
-    
-    private int multiplyChars(char a, char b) {
-        return Character.getNumericValue(a) * Character.getNumericValue(b); 
+    int zeroIdx = 0;
+    while (zeroIdx < ans.length && ans[zeroIdx] == 0) {
+      zeroIdx++;
     }
+    StringBuilder sb = new StringBuilder();
+    while (zeroIdx < ans.length) {
+      sb.append(ans[zeroIdx++]);
+    }
+    return sb.length() == 0 ? "0" : sb.toString();
+  }
 }

From 3959ebe2ff7df731e53605b327ca8c8ecde5d172 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 6 Apr 2020 13:20:15 -0700
Subject: [PATCH 0147/2175] Modified 3 solutions

---
 Easy/Intersection of two Linked Lists.java | 50 +++++++++++++++-------
 Medium/Coin Change.java                    | 41 +++++++++++-------
 Medium/Rectangle Area.java                 | 28 ++++++------
 3 files changed, 73 insertions(+), 46 deletions(-)

diff --git a/Easy/Intersection of two Linked Lists.java b/Easy/Intersection of two Linked Lists.java
index e2fd8de5..f515b847 100644
--- a/Easy/Intersection of two Linked Lists.java	
+++ b/Easy/Intersection of two Linked Lists.java	
@@ -10,19 +10,39 @@
  * }
  */
 public class Solution {
-    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
-        if (headA == null || headB == null) return null;
-        while (headA != null && headB != null) {
-            if (headA.val == headB.val) {
-                return headA;
-            }
-            else if (headA.val < headB.val) {
-                headA = headA.next;
-            }
-            else if (headA.val > headB.val) {
-                headB = headB.next;
-            }
-        }
-        return null;
+  public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+    int lenA = getLength(headA);
+    int lenB = getLength(headB);
+    ListNode currA = headA;
+    ListNode currB = headB;
+    if (lenA > lenB) {
+      int diff = lenA - lenB;
+      while (diff-- > 0) {
+        currA = currA.next;
+      }
     }
-}
\ No newline at end of file
+    if (lenB > lenA) {
+      int diff = lenB - lenA;
+      while (diff-- > 0) {
+        currB = currB.next;
+      }
+    }
+    while (currA != null && currB != null) {
+      if (currA == currB) {
+        return currA;
+      }
+      currA = currA.next;
+      currB = currB.next;
+    }
+    return null;
+  }
+  
+  private int getLength(ListNode node) {
+    int len = 0;
+    while (node != null) {
+      node = node.next;
+      len++;
+    }
+    return len;
+  }
+}
diff --git a/Medium/Coin Change.java b/Medium/Coin Change.java
index d87a7963..e5bfb1f1 100644
--- a/Medium/Coin Change.java	
+++ b/Medium/Coin Change.java	
@@ -1,18 +1,29 @@
 class Solution {
-    public int coinChange(int[] coins, int amount) {
-        int max = amount + 1;
-        int[] cache = new int[amount + 1];
-        Arrays.fill(cache, max);
-        cache[0] = 0;
-
-        for (int i=1; i<=amount; i++) {
-            for (int j=0; j<coins.length; j++) {
-                if (coins[j] <= i) {
-                    cache[i] = Math.min(cache[i], cache[i - coins[j]] + 1);
-                }
-            }
-        }
-
-        return cache[amount] > amount ? -1 : cache[amount];
+  public int coinChange(int[] coins, int amount) {
+    if (amount < 1) {
+      return 0;
     }
+    return coinChange(coins, amount, new int[amount]);
+  }
+  
+  private int coinChange(int[] coins, int amount, int[] memo) {
+    if (amount < 0) {
+      return -1;
+    }
+    if (amount == 0) {
+      return 0;
+    }
+    if (memo[amount - 1] != 0) {
+      return memo[amount - 1];
+    }
+    int min = Integer.MAX_VALUE;
+    for (int coin : coins) {
+      int res = coinChange(coins, amount - coin, memo);
+      if (res >= 0 && res < min) {
+        min = 1 + res;
+      }
+    }
+    memo[amount - 1] = min == Integer.MAX_VALUE ? -1 : min;
+    return memo[amount - 1];
+  }
 }
diff --git a/Medium/Rectangle Area.java b/Medium/Rectangle Area.java
index 463dd331..fbf0ca5f 100644
--- a/Medium/Rectangle Area.java	
+++ b/Medium/Rectangle Area.java	
@@ -1,19 +1,15 @@
 class Solution {
-    public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
-        int area = ((D - B) * (C - A)) + ((H - F) * (G- E));
-        area -= overlap(A, C, E, G) * overlap(B, D, F, H);
-        return area;
-    }
-    
-    private int overlap(int x1, int x2, int x3, int x4) {
-        if (x2 <= x3) {
-            return 0;
-        }
-        
-        if (x1 >= x4) {
-            return 0;
-        }
-        
-        return Math.min(x2, x4) - Math.max(x1, x3);
+  public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
+    int areaOfSqrA = (C - A) * (D - B);
+    int areaOfSqrB = (G - E) * (H - F);
+    int left = Math.max(A, E);
+    int right = Math.min(G, C);
+    int bottom = Math.max(F, B);
+    int top = Math.min(D, H);
+    int overlap = 0;
+    if(right > left && top > bottom) {
+      overlap = (right - left) * (top - bottom);
     }
+    return areaOfSqrA + areaOfSqrB - overlap;
+  }
 }

From 759a935b1c5e466b2797868760ed430afc2e9997 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 7 Apr 2020 15:28:59 -0700
Subject: [PATCH 0148/2175] Added 2 solutions & modified 1 solution

---
 Easy/Counting Elements.java       |  15 ++++
 Easy/Reverse Only Letters.java    |  23 ++++++
 Medium/Design Circular Queue.java | 133 ++++++++++++------------------
 3 files changed, 89 insertions(+), 82 deletions(-)
 create mode 100644 Easy/Counting Elements.java
 create mode 100644 Easy/Reverse Only Letters.java

diff --git a/Easy/Counting Elements.java b/Easy/Counting Elements.java
new file mode 100644
index 00000000..f24753ae
--- /dev/null
+++ b/Easy/Counting Elements.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int countElements(int[] arr) {
+    int[] counter = new int[1001];
+    for (int num : arr) {
+      counter[num]++;
+    }
+    int count = 0;
+    for (int i = 0; i < 1001; i++) {
+      if (i != 1000 && counter[i + 1] != 0) {
+        count += counter[i];
+      }
+    }
+    return count;
+  }
+}
diff --git a/Easy/Reverse Only Letters.java b/Easy/Reverse Only Letters.java
new file mode 100644
index 00000000..95aa10f5
--- /dev/null
+++ b/Easy/Reverse Only Letters.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public String reverseOnlyLetters(String S) {
+    int start = 0;
+    int end = S.length() - 1;
+    char[] chars = S.toCharArray();
+    while (start <= end) {
+      while (start <= end && !Character.isLetter(chars[start])) {
+        start++;
+      }
+      while (end >= start && !Character.isLetter(chars[end])) {
+        end--;
+      }
+      if (start <= end) {
+        char temp = chars[start];
+        chars[start] = chars[end];
+        chars[end] = temp;
+      }
+      start++;
+      end--;
+    }
+    return String.valueOf(chars);
+  }
+}
diff --git a/Medium/Design Circular Queue.java b/Medium/Design Circular Queue.java
index 236711ae..ee595135 100644
--- a/Medium/Design Circular Queue.java	
+++ b/Medium/Design Circular Queue.java	
@@ -1,92 +1,61 @@
 class MyCircularQueue {
 
-    /** Initialize your data structure here. Set the size of the queue to be k. */
-    Node head;
-    Node curr;
-    int capacity;
-    int count = 0;
-
-    public MyCircularQueue(int k) {
-        head = new Node(-1);
-        curr = head;
-        capacity = k;
+  /** Initialize your data structure here. Set the size of the queue to be k. */
+  int[] queue;
+  int start;
+  int end;
+  int k;
+  public MyCircularQueue(int k) {
+    this.k = k;
+    queue = new int[k];
+    start = 0;
+    end = 0;
+    Arrays.fill(queue, -1);
+  }
+
+  /** Insert an element into the circular queue. Return true if the operation is successful. */
+  public boolean enQueue(int value) {
+    if (end == start && queue[end] != -1) {
+      return false;
     }
-
-    /** Insert an element into the circular queue. Return true if the operation is successful. */
-    public boolean enQueue(int value) {
-        if (count == capacity) {
-            return false;
-        }
-
-        curr.next = new Node(value);
-        curr = curr.next;
-        count++;
-
-        return true;
+    queue[end++] = value;
+    if (end == k) {
+      end = 0;
     }
+    return true;
+  }
 
-    /** Delete an element from the circular queue. Return true if the operation is successful. */
-    public boolean deQueue() {
-        if (count <= 0) {
-            return false;
-        }
-
-        if (head.next == curr) {
-            curr = head;
-            head.next = null;
-        }
-        else {
-            head.next = head.next.next;
-        }
-
-        count--;
-
-        return true;
+  /** Delete an element from the circular queue. Return true if the operation is successful. */
+  public boolean deQueue() {
+    if (queue[start] == -1) {
+      return false;
     }
-
-    /** Get the front item from the queue. */
-    public int Front() {
-        if (count == 0) {
-            return -1;
-        }
-
-        return head.next.value;
-    }
-
-    /** Get the last item from the queue. */
-    public int Rear() {
-        if (count == 0) {
-            return -1;
-        }
-
-        return curr.value;
-    }
-
-    /** Checks whether the circular queue is empty or not. */
-    public boolean isEmpty() {
-        return count == 0;
-    }
-
-    /** Checks whether the circular queue is full or not. */
-    public boolean isFull() {
-        return count == capacity;
-    }
-
-    private void printList(Node node) {
-        while (node != null) {
-            System.out.print(node.value + " ");
-        }
-
-        System.out.println();
-    }
-
-    class Node {
-        int value;
-        Node next;
-        Node(int value) {
-            this.value = value;
-        }
+    queue[start++] = -1;
+    if (start == k) {
+      start = 0;
     }
+    return true;
+  }
+
+  /** Get the front item from the queue. */
+  public int Front() {
+    return queue[start];
+  }
+
+  /** Get the last item from the queue. */
+  public int Rear() {
+    return end == 0 ? queue[k - 1] : queue[end - 1];
+  }
+
+  /** Checks whether the circular queue is empty or not. */
+  public boolean isEmpty() {
+    return start == end && queue[end] == -1;
+  }
+
+  /** Checks whether the circular queue is full or not. */
+  public boolean isFull() {
+    return start == end && queue[end] != -1;
+  }
 }
 
 /**

From e880e3654a32afc684c9f57d1d5a7b799188be76 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 8 Apr 2020 16:13:07 -0700
Subject: [PATCH 0149/2175] Added 1 solution & modified 1 solution

---
 Easy/Middle of the linked list.java           | 28 ++++++-------------
 ...m Subsequence in Non-Increasing Order.java | 23 +++++++++++++++
 2 files changed, 31 insertions(+), 20 deletions(-)
 create mode 100644 Easy/Minimum Subsequence in Non-Increasing Order.java

diff --git a/Easy/Middle of the linked list.java b/Easy/Middle of the linked list.java
index 09182730..8601522e 100644
--- a/Easy/Middle of the linked list.java	
+++ b/Easy/Middle of the linked list.java	
@@ -7,25 +7,13 @@
  * }
  */
 class Solution {
-    public ListNode middleNode(ListNode head) {
-        int l = getLengthOfLinkedList(head);
-        int mid = l/2;
-        
-        while (mid > 0) {
-            head = head.next;
-            mid--;
-        }
-        
-        return head;
-    }
-    
-    private int getLengthOfLinkedList(ListNode head) {
-        int c = 0;
-        while(head != null) {
-            head = head.next;
-            c++;
-        }
-        
-        return c;
+  public ListNode middleNode(ListNode head) {
+    ListNode slow = head;
+    ListNode fast = head;
+    while (fast != null && fast.next != null) {
+      slow = slow.next;
+      fast = fast.next.next;
     }
+    return slow;
+  }
 }
diff --git a/Easy/Minimum Subsequence in Non-Increasing Order.java b/Easy/Minimum Subsequence in Non-Increasing Order.java
new file mode 100644
index 00000000..8494bb24
--- /dev/null
+++ b/Easy/Minimum Subsequence in Non-Increasing Order.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public List<Integer> minSubsequence(int[] nums) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
+      public int compare(Integer o1, Integer o2) {
+        return o2 - o1;
+      }
+    });
+    int totalSum = 0;
+    for (int num : nums) {
+      pq.add(num);
+      totalSum += num;
+    }
+    List<Integer> list = new ArrayList<>();
+    int currSum = 0;
+    while (currSum <= totalSum) {
+      int num = pq.poll();
+      currSum += num;
+      totalSum -= num;
+      list.add(num);
+    }
+    return list;
+  }
+}

From 18af62e4624f33274992141061d8aeb58be7ceb1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 13 Apr 2020 17:38:43 -0700
Subject: [PATCH 0150/2175] Modified 2 solutions

---
 Easy/Longest Word in Dictionary.java | 61 ++++++++++++++++++++++------
 Medium/Contiguous Array.java         | 32 +++++++--------
 2 files changed, 63 insertions(+), 30 deletions(-)

diff --git a/Easy/Longest Word in Dictionary.java b/Easy/Longest Word in Dictionary.java
index 8a8a99ee..f83e2d62 100644
--- a/Easy/Longest Word in Dictionary.java	
+++ b/Easy/Longest Word in Dictionary.java	
@@ -1,16 +1,51 @@
 class Solution {
-    public String longestWord(String[] words) {
-        Arrays.sort(words);
-        
-        Set<String> built = new HashSet<String>();
-        String ans = "";
-        
-        for (String word : words) {
-            if (word.length() == 1 || built.contains(word.substring(0, word.length() - 1))) {
-                ans = word.length() > ans.length() ? word : ans;
-                built.add(word);
-            }
-        }
-        return ans;
+  Map<Integer, List<String>> map;
+  int maxVal;
+  public String longestWord(String[] words) {
+    map = new HashMap<>();
+    maxVal = Integer.MIN_VALUE;
+    Node root = new Node('-');
+    Arrays.sort(words);
+    for (String word : words) {
+      addWord(word, root, 0);
     }
+    if (maxVal == Integer.MIN_VALUE) {
+      return "";
+    }
+    List<String> possibleAns = map.get(maxVal);
+    Collections.sort(possibleAns);
+    return possibleAns.get(0);
+  }
+  
+  private void addWord(String word, Node root, int idx) {
+    char c = word.charAt(idx);
+    if (!root.children.containsKey(c) && idx != word.length() - 1) {
+      return;
+    }
+    if (!root.children.containsKey(c)) {
+      root.children.put(c, new Node(c));
+    }
+    root = root.children.get(c);
+    if (idx == word.length() - 1) {
+      root.isWord = true;
+      int wordLength = word.length();
+      map.computeIfAbsent(wordLength, k -> new ArrayList<>()).add(word);
+      maxVal = Math.max(maxVal, wordLength);
+    }
+    else {
+      addWord(word, root, idx + 1);
+    }
+  }
+}
+
+class Node {
+  char val;
+  boolean isWord;
+  Map<Character, Node> children;
+  
+  public Node(char val) {
+    this.val = val;
+    isWord = true;
+    children = new HashMap<>();
+  }
 }
diff --git a/Medium/Contiguous Array.java b/Medium/Contiguous Array.java
index e466caf1..554d8c65 100644
--- a/Medium/Contiguous Array.java	
+++ b/Medium/Contiguous Array.java	
@@ -1,20 +1,18 @@
 class Solution {
-    public int findMaxLength(int[] nums) {  
-        Map<Integer, Integer> map = new HashMap<>();
-        map.put(0, -1);
-        int maxLen = 0;
-        int count = 0;
-        
-        for (int i=0; i<nums.length; i++) {
-            count += nums[i] == 0 ? -1 : 1;
-            if (map.containsKey(count)) {
-                maxLen = Math.max(maxLen, i-map.get(count));
-            }
-            else {
-                map.put(count, i);
-            }
-        }
-        
-        return maxLen;
+  public int findMaxLength(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    map.put(0, -1);
+    int maxLen = 0;
+    int count = 0;
+    for (int i = 0; i < nums.length; i++) {
+      count += nums[i] == 0 ? -1 : 1;
+      if (map.containsKey(count)) {
+        maxLen = Math.max(maxLen, i - map.get(count));
+      }
+      else {
+        map.put(count, i);
+      }
     }
+    return maxLen;
+  }
 }

From 68ecac588ad4be7ba8aa0e16002d42a0efd915eb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 15 Apr 2020 17:13:34 -0700
Subject: [PATCH 0151/2175] Added 1 solution & modified 1 solution

---
 Easy/Degree of an array.java    | 58 ++++++++++++---------------------
 Easy/Perform String Shifts.java | 48 +++++++++++++++++++++++++++
 2 files changed, 68 insertions(+), 38 deletions(-)
 create mode 100644 Easy/Perform String Shifts.java

diff --git a/Easy/Degree of an array.java b/Easy/Degree of an array.java
index 70d31543..f4c3f2f3 100644
--- a/Easy/Degree of an array.java	
+++ b/Easy/Degree of an array.java	
@@ -1,42 +1,24 @@
 class Solution {
-    public int findShortestSubArray(int[] nums) {
-        Map<Integer, Entry> map = new HashMap<>();
-        
-        for (int i = 0; i < nums.length; i++) {
-            if (map.containsKey(nums[i])) {
-                map.get(nums[i]).degree++;
-                map.get(nums[i]).endIdx = i;
-            }
-            else {
-                map.put(nums[i], new Entry(1, i, i));
-            }
-        }
-        
-        int res = Integer.MAX_VALUE;
-        int degree = Integer.MIN_VALUE;
-        
-        for (Entry entry : map.values()) {
-            if (degree < entry.degree) {
-                degree = entry.degree;
-                res = entry.endIdx - entry.startIdx + 1;
-            }    
-            else if (degree == entry.degree) {
-                res = Math.min(entry.endIdx - entry.startIdx + 1, res);
-            }
-        }
-        
-        return res;
+  public int findShortestSubArray(int[] nums) {
+    Map<Integer, Integer> count = new HashMap<>();
+    Map<Integer, Integer> left = new HashMap<>();
+    Map<Integer, Integer> right = new HashMap<>();
+    int degree = 0;
+    for (int i = 0; i < nums.length; i++) {
+      int num = nums[i];
+      if (!left.containsKey(num)) {
+        left.put(num, i);
+      }
+      right.put(num, i);
+      count.put(num, count.getOrDefault(num, 0) + 1);
+      degree = Math.max(degree, count.get(num));
     }
-
-    class Entry {
-        int degree;
-        int startIdx;
-        int endIdx;
-        
-        public Entry(int degree, int startIdx, int endIdx) {
-            this.degree = degree;
-            this.startIdx = startIdx;
-            this.endIdx = endIdx;
-        }
+    int ans = nums.length;
+    for (int key : count.keySet()) {
+      if (count.get(key) == degree) {
+        ans = Math.min(ans, right.get(key) - left.get(key) + 1);
+      }
     }
+    return ans;
+  }
 }
diff --git a/Easy/Perform String Shifts.java b/Easy/Perform String Shifts.java
new file mode 100644
index 00000000..acd5d6fc
--- /dev/null
+++ b/Easy/Perform String Shifts.java	
@@ -0,0 +1,48 @@
+class Solution {
+  public String stringShift(String s, int[][] shifts) {
+    int leftShiftAmount = 0;
+    int rightShiftAmount = 0;
+    for (int[] shift : shifts) {
+      if (shift[0] == 0) {
+        leftShiftAmount += shift[1];
+      }
+      else {
+        rightShiftAmount += shift[1];
+      }
+    }
+    if (leftShiftAmount > rightShiftAmount) {
+      return shiftLeft(s, leftShiftAmount - rightShiftAmount);
+    }
+    else if (rightShiftAmount > leftShiftAmount) {
+      return shiftRight(s, rightShiftAmount - leftShiftAmount);
+    }
+    else {
+      return s;
+    }
+  }
+  
+  private String shiftLeft(String s, int n) {
+    StringBuilder sb = new StringBuilder();
+    n %= s.length();
+    for (int i = n; i < s.length(); i++) {
+      sb.append(s.charAt(i));
+    }
+    for (int i = 0; i < n; i++) {
+      sb.append(s.charAt(i));
+    }
+    return sb.toString();
+  }
+  
+  private String shiftRight(String s, int n) {
+    StringBuilder sb = new StringBuilder();
+    n %= s.length();
+    int len = s.length();
+    for (int i = 0; i < len - n; i++) {
+      sb.append(s.charAt(i));
+    }
+    for (int i = s.length() - 1; i >= len - n; i--) {
+      sb.insert(0, s.charAt(i));
+    }
+    return sb.toString();
+  }
+}

From 20b239d1dd10cd4a3598c1252afd4e38792b9f8d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 16 Apr 2020 18:22:56 -0700
Subject: [PATCH 0152/2175] Added Valid Parenthesis String.java

---
 Medium/Valid Parenthesis String.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Valid Parenthesis String.java

diff --git a/Medium/Valid Parenthesis String.java b/Medium/Valid Parenthesis String.java
new file mode 100644
index 00000000..f4ffdb1c
--- /dev/null
+++ b/Medium/Valid Parenthesis String.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public boolean checkValidString(String s) {
+    int low = 0;
+    int high = 0;
+    for (char c : s.toCharArray()) {
+      low += c == '(' ? 1 : -1;
+      high += c != ')' ? 1 : -1;
+      if (high < 0) {
+        break;
+      }
+      low = Math.max(low, 0);
+    }
+    return low == 0;
+  }
+}

From 32207f5dba714f9c0d1f6a490d26b0203de978e4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 22 Apr 2020 12:15:30 -0700
Subject: [PATCH 0153/2175] Added 1 solution & modified 1 solution

---
 Easy/Palindrome Permutation.java              | 34 +++++++---------
 .../Leftmost Column with at Least a One.java  | 39 +++++++++++++++++++
 2 files changed, 53 insertions(+), 20 deletions(-)
 create mode 100644 Medium/Leftmost Column with at Least a One.java

diff --git a/Easy/Palindrome Permutation.java b/Easy/Palindrome Permutation.java
index 5ff21be3..5397212d 100644
--- a/Easy/Palindrome Permutation.java	
+++ b/Easy/Palindrome Permutation.java	
@@ -1,24 +1,18 @@
 class Solution {
-    public static boolean canPermutePalindrome(String s) {
-        Map<Character, Integer> map = new HashMap<>();
-        char[] chars = s.toCharArray();
-        
-        for (char c : chars) {
-            map.put(c, map.getOrDefault(c, 0) + 1);
-        }
-        
-        int oddVal = 0;
-        
-        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
-            if (entry.getValue()%2 != 0) {
-                oddVal++;
-            }
-            
-            if (oddVal == 2) {
-                return false;
-            }
+  public boolean canPermutePalindrome(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      map.put(c, map.getOrDefault(c, 0) + 1);
+    }
+    boolean oddFound = false;
+    for (Character key : map.keySet()) {
+      if (map.get(key) % 2 != 0) {
+        if (oddFound) {
+          return false;
         }
-        
-        return true;
+        oddFound = true;
+      }
     }
+    return true;
+  }
 }
diff --git a/Medium/Leftmost Column with at Least a One.java b/Medium/Leftmost Column with at Least a One.java
new file mode 100644
index 00000000..2cda1b1c
--- /dev/null
+++ b/Medium/Leftmost Column with at Least a One.java	
@@ -0,0 +1,39 @@
+/**
+ * // This is the BinaryMatrix's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface BinaryMatrix {
+ *     public int get(int x, int y) {}
+ *     public List<Integer> dimensions {}
+ * };
+ */
+
+class Solution {
+  public int leftMostColumnWithOne(BinaryMatrix binaryMatrix) {
+    List<Integer> dims = binaryMatrix.dimensions();
+    int rows = dims.get(0);
+    int cols = dims.get(1);
+    int minIdx = Integer.MAX_VALUE;
+    for (int i = 0; i < rows; i++) {
+      int idx = binarySearch(binaryMatrix, i, 0, cols - 1);
+      if (idx != -1) {
+        minIdx = Math.min(minIdx, idx);
+      }
+    }
+    return minIdx == Integer.MAX_VALUE ? -1 : minIdx;
+  }
+  
+  private int binarySearch(BinaryMatrix binaryMatrix, int row, int start, int end) {
+    int minIdx = Integer.MAX_VALUE;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (binaryMatrix.get(row, mid) == 1) {
+        minIdx = Math.min(minIdx, mid);
+        end = mid - 1;
+      }
+      else {
+        start = mid + 1;
+      }
+    }
+    return minIdx == Integer.MAX_VALUE ? -1 : minIdx;
+  }
+}

From d580a2b2ac93fe3ee7b5e86cb9cb8bc67b9cf31c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Apr 2020 11:19:22 -0700
Subject: [PATCH 0154/2175] Added 1 solution & modified 1 solution

---
 Easy/Reformat The String.java       | 36 ++++++++++++++++++
 Medium/Find K Closest Elements.java | 58 +++++++++++++++++------------
 2 files changed, 71 insertions(+), 23 deletions(-)
 create mode 100644 Easy/Reformat The String.java

diff --git a/Easy/Reformat The String.java b/Easy/Reformat The String.java
new file mode 100644
index 00000000..8c91c9a5
--- /dev/null
+++ b/Easy/Reformat The String.java	
@@ -0,0 +1,36 @@
+class Solution {
+  public String reformat(String s) {
+    List<Character> letters = new ArrayList<>();
+    List<Character> digits = new ArrayList<>();
+    for (char c : s.toCharArray()) {
+      if (Character.isLetter(c)) {
+        letters.add(c);
+      }
+      else {
+        digits.add(c);
+      }
+    }
+    if (Math.abs(letters.size() - digits.size()) > 1) {
+      return "";
+    }
+    return letters.size() > digits.size() ? formPermutation(letters, digits) : formPermutation(digits, letters);
+  }
+  
+  private String formPermutation(List<Character> l1, List<Character> l2) {
+    StringBuilder sb = new StringBuilder();
+    int idx1 = 0;
+    int idx2 = 0;
+    boolean isL1 = true;
+    while (idx1 < l1.size() && idx2 < l2.size()) {
+      sb.append(isL1 ? l1.get(idx1++) : l2.get(idx2++));
+      isL1 = !isL1;
+    }
+    if (idx1 < l1.size()) {
+      sb.append(l1.get(idx1));
+    }
+    if (idx2 < l2.size()) {
+      sb.append(l2.get(idx2));
+    }
+    return sb.toString();
+  }
+}
diff --git a/Medium/Find K Closest Elements.java b/Medium/Find K Closest Elements.java
index 5ffc56a8..76a292bb 100644
--- a/Medium/Find K Closest Elements.java	
+++ b/Medium/Find K Closest Elements.java	
@@ -1,29 +1,41 @@
 class Solution {
-    public List<Integer> findClosestElements(int[] arr, int k, int x) {
-        if (x <= arr[0]) {
-            return Arrays.stream(arr).boxed().collect(Collectors.toList()).subList(0, k);
-        }
-        else if (x >= arr[arr.length - 1]) {
-            return Arrays.stream(arr).boxed().collect(Collectors.toList()).subList(arr.length - k, arr.length);
+  public List<Integer> findClosestElements(int[] arr, int k, int x) {
+    if (k == 0 || arr.length == 0) {
+      return new ArrayList<>();
+    }
+    int[] diffArr = new int[arr.length];
+    int minDiff = Integer.MAX_VALUE;
+    int minDiffIdx = -1;
+    for (int i = 0; i < arr.length; i++) {
+      diffArr[i] = Math.abs(arr[i] - x);
+      if (minDiff > diffArr[i]) {
+        minDiff = diffArr[i];
+        minDiffIdx = i;
+      }
+    }
+    int left = minDiffIdx - 1;
+    int right = minDiffIdx + 1;
+    List<Integer> list = new ArrayList<>();
+    list.add(arr[minDiffIdx]);
+    k--;
+    while (k > 0) {
+      if (left >= 0 && right < arr.length) {
+        if (diffArr[left] <= diffArr[right]) {
+          list.add(arr[left--]);
         }
         else {
-            int idx = Arrays.binarySearch(arr, x);
-            if (idx < 0) {
-                idx = -idx - 1;
-            }
-            int low = Math.max(0, idx - k - 1);
-            int high = Math.min(arr.length - 1, idx + k - 1);
-
-            while (high - low > k - 1) {
-                if (low < 0 || (x - arr[low]) <= (arr[high] - x)) {
-                    high--;
-                }
-                else if ((high > arr.length - 1 || (x - arr[low]) > (arr[high] - x))) {
-                    low++;
-                }
-            }
-
-            return Arrays.stream(arr).boxed().collect(Collectors.toList()).subList(low, high + 1);
+          list.add(arr[right++]);
         }
+      }
+      else if (left >= 0 && right == arr.length) {
+        list.add(arr[left--]);
+      }
+      else {
+        list.add(arr[right++]);
+      }
+      k--;
     }
+    Collections.sort(list);
+    return list;
+  }
 }

From 541379ba7595726b48a17816845fc5354adff60e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Apr 2020 12:21:08 -0700
Subject: [PATCH 0155/2175] Added Display Table of Food Orders in a
 Restaurant.java

---
 ... Table of Food Orders in a Restaurant.java | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 Medium/Display Table of Food Orders in a Restaurant.java

diff --git a/Medium/Display Table of Food Orders in a Restaurant.java b/Medium/Display Table of Food Orders in a Restaurant.java
new file mode 100644
index 00000000..31b32703
--- /dev/null
+++ b/Medium/Display Table of Food Orders in a Restaurant.java	
@@ -0,0 +1,33 @@
+class Solution {
+  public List<List<String>> displayTable(List<List<String>> orders) {
+    Map<Integer, Map<String, Integer>> map = new HashMap<>();
+    Set<Integer> tablesOrdered = new TreeSet<>();
+    Set<String> possibleItems = new TreeSet<>();
+    for (List<String> order : orders) {
+      int tableId = Integer.parseInt(order.get(1));
+      for (int i = 2; i < order.size(); i++) {
+        map.computeIfAbsent(tableId, k -> new HashMap<>());
+        Map<String, Integer> tableMap = map.get(tableId);
+        tableMap.put(order.get(i), tableMap.getOrDefault(order.get(i), 0) + 1);
+        possibleItems.add(order.get(i));
+      }
+      tablesOrdered.add(tableId);
+    }
+    List<List<String>> list = new ArrayList<>();
+    List<String> temp = new ArrayList<>();
+    temp.add("Table");
+    temp.addAll(possibleItems);
+    list.add(temp);
+    temp = new ArrayList<>();
+    for (Integer table : tablesOrdered) {
+      Map<String, Integer> tableMap = map.get(table);
+      temp.add(String.valueOf(table));
+      for (String item : possibleItems) {
+        temp.add(String.valueOf(tableMap.getOrDefault(item, 0)));
+      }
+      list.add(temp);
+      temp = new ArrayList<>();
+    }
+    return list;
+  }
+}

From a4cfa7dff2aed9b31dcab2ec47d643aab506f97f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 28 Apr 2020 15:10:33 -0700
Subject: [PATCH 0156/2175] Added First Unique Number.java

---
 Medium/First Unique Number.java | 44 +++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 Medium/First Unique Number.java

diff --git a/Medium/First Unique Number.java b/Medium/First Unique Number.java
new file mode 100644
index 00000000..5a2808cd
--- /dev/null
+++ b/Medium/First Unique Number.java	
@@ -0,0 +1,44 @@
+class FirstUnique {
+  Map<Integer, Integer> valToCount;
+  Map<Integer, Integer> countToVal;
+  int count;
+  int lowest;
+  public FirstUnique(int[] nums) {
+    valToCount = new HashMap<>();
+    countToVal = new HashMap<>();
+    count = 0;
+    lowest = 0;
+    for (int num : nums) {
+      add(num);
+    }
+  }
+
+  public int showFirstUnique() {
+    while (lowest < count && countToVal.get(lowest) == -1) {
+      lowest++;
+    }
+    if (lowest == count) {
+      lowest--;
+      return -1;
+    }
+    return countToVal.get(lowest);
+  }
+
+  public void add(int value) {
+    if (valToCount.containsKey(value)) {
+      int idx = valToCount.get(value);
+      countToVal.put(idx, -1);
+    }
+    else {
+      valToCount.put(value, count++);
+      countToVal.put(valToCount.get(value), value);
+    }
+  }
+}
+
+/**
+ * Your FirstUnique object will be instantiated and called as such:
+ * FirstUnique obj = new FirstUnique(nums);
+ * int param_1 = obj.showFirstUnique();
+ * obj.add(value);
+ */

From 55b76bec9f67eda35d50ce3c40688bb59e83fe7e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 28 Apr 2020 15:20:22 -0700
Subject: [PATCH 0157/2175] Updated First Unique Number.java using linked list

---
 Medium/First Unique Number.java | 60 +++++++++++++++++++++------------
 1 file changed, 39 insertions(+), 21 deletions(-)

diff --git a/Medium/First Unique Number.java b/Medium/First Unique Number.java
index 5a2808cd..9a0dd44e 100644
--- a/Medium/First Unique Number.java	
+++ b/Medium/First Unique Number.java	
@@ -1,39 +1,57 @@
 class FirstUnique {
-  Map<Integer, Integer> valToCount;
-  Map<Integer, Integer> countToVal;
-  int count;
-  int lowest;
+  Node head;
+  Node tail;
+  Map<Integer, Node> map;
+  int MX_VAL = Integer.MAX_VALUE;
+  int MN_VAL = Integer.MIN_VALUE;
   public FirstUnique(int[] nums) {
-    valToCount = new HashMap<>();
-    countToVal = new HashMap<>();
-    count = 0;
-    lowest = 0;
+    map = new HashMap<>();
+    head = new Node(MN_VAL);
+    tail = new Node(MX_VAL);
+    head.next = tail;
+    tail.prev = head;
     for (int num : nums) {
       add(num);
     }
   }
 
   public int showFirstUnique() {
-    while (lowest < count && countToVal.get(lowest) == -1) {
-      lowest++;
-    }
-    if (lowest == count) {
-      lowest--;
-      return -1;
-    }
-    return countToVal.get(lowest);
+    return head.next.val == MX_VAL ? -1 : head.next.val;
   }
 
   public void add(int value) {
-    if (valToCount.containsKey(value)) {
-      int idx = valToCount.get(value);
-      countToVal.put(idx, -1);
+    if (map.containsKey(value)) {
+      if (map.get(value) != null) {
+        remove(map.get(value));
+        map.put(value, null);
+      }
     }
     else {
-      valToCount.put(value, count++);
-      countToVal.put(valToCount.get(value), value);
+      Node newNode = new Node(value);
+      map.put(value, newNode);
+      newNode.prev = tail.prev;
+      tail.prev.next = newNode;
+      newNode.next = tail;
+      tail.prev = newNode;
     }
   }
+  
+  private void remove(Node node) {
+    Node prev = node.prev;
+    Node next = node.next;
+    prev.next = next;
+    next.prev = prev;
+  }
+}
+
+class Node {
+  int val;
+  Node next;
+  Node prev;
+  
+  public Node(int val) {
+    this.val = val;
+  }
 }
 
 /**

From aa1f02e76d6baf71a4872fd1d5737e21503dc19c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 30 Apr 2020 09:44:05 -0700
Subject: [PATCH 0158/2175] Added Check If a String Is a Valid Sequence from
 Root to Leaves Path in a Binary Tree.java

---
 ... Root to Leaves Path in a Binary Tree.java | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 Medium/Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree.java

diff --git a/Medium/Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree.java b/Medium/Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree.java
new file mode 100644
index 00000000..df07904f
--- /dev/null
+++ b/Medium/Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree.java	
@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public boolean isValidSequence(TreeNode root, int[] arr) {
+    return helper(root, arr, 0);
+  }
+  
+  private boolean helper(TreeNode root, int[] arr, int idx) {
+    if (root == null || idx >= arr.length) {
+      return false;
+    }
+    if (root.val != arr[idx]) {
+      return false;
+    }
+    if (root.left == null && root.right == null && idx == (arr.length - 1)) {
+      return true;
+    }
+    return helper(root.left, arr, idx + 1) || helper(root.right, arr, idx + 1);
+  }
+}

From a11895f48f152c5d31219569df87282fda6373dd Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 1 May 2020 10:51:57 -0700
Subject: [PATCH 0159/2175] Modified First Bad Version.java

---
 Easy/First Bad Version.java | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/Easy/First Bad Version.java b/Easy/First Bad Version.java
index 7e86899b..04e7c14b 100644
--- a/Easy/First Bad Version.java	
+++ b/Easy/First Bad Version.java	
@@ -2,18 +2,21 @@
       boolean isBadVersion(int version); */
 
 public class Solution extends VersionControl {
-    public int firstBadVersion(int n) {
-        int start = 1;
-        int end = n;
-        while (start < end) {
-            int mid = start + (end - start)/2;
-            if (!isBadVersion(mid)) {
-                start = mid + 1;
-            }
-            else {
-                end = mid;
-            }
+  public int firstBadVersion(int n) {
+    int start = 1;
+    int end = n;
+    while (start < end) {
+      int mid = start + (end - start) / 2;
+      if (isBadVersion(mid)) {
+        if (mid == 1 || isBadVersion(mid - 1) == false) {
+          return mid;
         }
-        return start;
+        end = mid - 1;
+      }
+      else {
+        start = mid + 1;
+      }
     }
+    return start;
+  } 
 }

From f0cac9e80a390700d7d24a888c00856a46c09818 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 2 May 2020 19:00:32 -0700
Subject: [PATCH 0160/2175] Added 1 solution & modified 1 solution

---
 Easy/Jewels and Stones.java                   | 34 ++++++++-----------
 ...s With the Greatest Number of Candies.java | 13 +++++++
 2 files changed, 28 insertions(+), 19 deletions(-)
 create mode 100644 Easy/Kids With the Greatest Number of Candies.java

diff --git a/Easy/Jewels and Stones.java b/Easy/Jewels and Stones.java
index 199feb24..6a318480 100644
--- a/Easy/Jewels and Stones.java	
+++ b/Easy/Jewels and Stones.java	
@@ -1,23 +1,19 @@
 class Solution {
-    public int numJewelsInStones(String J, String S) {
-        boolean[] isSet = new boolean[52];
-        for (char c : J.toCharArray()) {
-            isSet[getIdx(c)] = true;
-        }
-        
-        int count = 0;
-        for (char c : S.toCharArray()) {
-            count += isSet[getIdx(c)] ? 1 : 0;    
-        }
-        
-        return count;
+  public int numJewelsInStones(String J, String S) {
+    Map<Character, Integer> mapJ = getMap(J);
+    Map<Character, Integer> mapS = getMap(S);
+    int count = 0;
+    for (Character key : mapJ.keySet()) {
+      count += mapS.getOrDefault(key, 0);
     }
-    
-    private int getIdx(char c) {
-        if (Character.isUpperCase(c)) {
-            return 26 + c - 'A';
-        }
-        
-        return c - 'a';
+    return count;
+  }
+  
+  private Map<Character, Integer> getMap(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      map.put(c, map.getOrDefault(c, 0) + 1);
     }
+    return map;
+  }
 }
diff --git a/Easy/Kids With the Greatest Number of Candies.java b/Easy/Kids With the Greatest Number of Candies.java
new file mode 100644
index 00000000..69e60fb2
--- /dev/null
+++ b/Easy/Kids With the Greatest Number of Candies.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
+    int max = Integer.MIN_VALUE;
+    for (int candy : candies) {
+      max = Math.max(max, candy);
+    }
+    List<Boolean> ans = new ArrayList<>();
+    for (int i = 0; i < candies.length; i++) {
+      ans.add((candies[i] + extraCandies) >= max);
+    }
+    return ans;
+  }
+}

From 9bbc4f0347ce83e77eeb1a436e8090addfcea8fe Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 3 May 2020 14:23:45 -0700
Subject: [PATCH 0161/2175] Added Destination City.java

---
 Easy/Destination City.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Destination City.java

diff --git a/Easy/Destination City.java b/Easy/Destination City.java
new file mode 100644
index 00000000..c9f08cbc
--- /dev/null
+++ b/Easy/Destination City.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public String destCity(List<List<String>> paths) {
+    Set<String> outgoingPathCities = new HashSet<>();
+    Set<String> cities = new HashSet<>();
+    for (List<String> path : paths) {
+      outgoingPathCities.add(path.get(0));
+      cities.add(path.get(0));
+      cities.add(path.get(1));
+    }
+    for (String city : cities) {
+      if (!outgoingPathCities.contains(city)) {
+        return city;
+      }
+    }
+    return "";
+  }
+}

From cf73b8b838246320d6f7d03ada4b922d66074265 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 6 May 2020 12:30:37 -0700
Subject: [PATCH 0162/2175] Added 1 solution & modified 1 solution

---
 Easy/Number Complement.java              | 51 ++++++++----------------
 Easy/X of a Kind in a Deck of Cards.java | 31 ++++++++++++++
 2 files changed, 48 insertions(+), 34 deletions(-)
 create mode 100644 Easy/X of a Kind in a Deck of Cards.java

diff --git a/Easy/Number Complement.java b/Easy/Number Complement.java
index 889c873c..10cfc993 100644
--- a/Easy/Number Complement.java	
+++ b/Easy/Number Complement.java	
@@ -1,38 +1,21 @@
 class Solution {
-    public int findComplement(int num) {
-        return getDecimalVal(flip(getBinaryVal(num)));
+  public int findComplement(int num) {
+    StringBuilder sb = new StringBuilder();
+    while (num > 0) {
+      int rem = num % 2;
+      num /= 2;
+      sb.append(rem);
     }
-    
-    public String getBinaryVal(int n) {
-        StringBuilder sb = new StringBuilder();
-        while (n > 0) {
-            sb.append(String.valueOf(n%2));
-            n /= 2;
-        }
-        return sb.reverse().toString();
+    StringBuilder complement = new StringBuilder();
+    for (int i = 0; i < sb.length(); i++) {
+      complement.append(sb.charAt(i) == '1' ? '0' : '1');
     }
-
-    public String flip(String s) {
-        StringBuilder sb = new StringBuilder();
-        for (int i=0;i<s.length();i++) {
-            if (s.charAt(i) == '1') {
-                sb.append("0");
-            }
-            else {
-                sb.append("1");
-            }
-        }
-        return sb.reverse().toString();
+    int newNum = 0;
+    int pow = 0;
+    for (int i = 0; i < complement.length(); i++) {
+      newNum += ((int) Math.pow(2, pow)) * Character.getNumericValue(complement.charAt(i));
+      pow++;
     }
-
-    public int getDecimalVal(String s) {
-        int n = 0;
-
-        for (int i=0;i<s.length();i++) {
-            int mul = (int)Math.pow(2, i);
-            int num = Integer.parseInt(String.valueOf(s.charAt(i)));
-            n += mul*num;
-        }
-        return n;
-    }
-}
\ No newline at end of file
+    return newNum;
+  }
+}
diff --git a/Easy/X of a Kind in a Deck of Cards.java b/Easy/X of a Kind in a Deck of Cards.java
new file mode 100644
index 00000000..a11d0044
--- /dev/null
+++ b/Easy/X of a Kind in a Deck of Cards.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public boolean hasGroupsSizeX(int[] deck) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int maxGroupCount = Integer.MIN_VALUE;
+    for (int card : deck) {
+      map.put(card, map.getOrDefault(card, 0) + 1);
+      maxGroupCount = Math.max(maxGroupCount, map.get(card));
+    }
+    for (Integer key : map.keySet()) {
+      if (map.get(key) < 2) {
+        return false;
+      }
+    }
+    for (int i = 2; i <= maxGroupCount; i++) {
+      boolean allPaired = true;
+      for (Integer key : map.keySet()) {
+        if (map.get(key) < i) {
+          return false;
+        }
+        if (map.get(key) % i != 0) {
+          allPaired = false;
+          break;
+        }
+      }
+      if (allPaired) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

From e5890c08160c391cc1f5632ed8157aea2313ce81 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 8 May 2020 14:35:30 -0700
Subject: [PATCH 0163/2175] Added Check If It Is a Straight Line.java

---
 Easy/Check If It Is a Straight Line.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Easy/Check If It Is a Straight Line.java

diff --git a/Easy/Check If It Is a Straight Line.java b/Easy/Check If It Is a Straight Line.java
new file mode 100644
index 00000000..18798145
--- /dev/null
+++ b/Easy/Check If It Is a Straight Line.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public boolean checkStraightLine(int[][] coordinates) {
+    if (coordinates.length <= 2) {
+      return true;
+    }
+    int[] p1 = coordinates[0];
+    int[] p2 = coordinates[1];
+    for (int i = 2; i < coordinates.length; i++) {
+      if (!isCollinear(coordinates[i], p1, p2)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  private boolean isCollinear(int[] c, int[] p1, int[] p2) {
+    if (p1[0] == c[0] || p2[0] == c[0]) {
+      return false;
+    }
+    int slope1 = (p1[1] - c[1]) / (p1[0] - c[0]);
+    int slope2 = (p2[1] - c[1]) / (p2[0] - c[0]);
+    return slope1 == slope2;
+  }
+}

From 9bd51faec9a4d5c13644fa8156611693a91ebf9f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 9 May 2020 14:58:05 -0700
Subject: [PATCH 0164/2175] Added 1 solution & modified 1 solution

---
 Easy/Valid Perfect Square.java                | 27 +++++++++++++------
 ...ount Square Submatrices with All Ones.java | 16 +++++++++++
 2 files changed, 35 insertions(+), 8 deletions(-)
 create mode 100644 Medium/Count Square Submatrices with All Ones.java

diff --git a/Easy/Valid Perfect Square.java b/Easy/Valid Perfect Square.java
index fd931dc8..ec870dd1 100644
--- a/Easy/Valid Perfect Square.java	
+++ b/Easy/Valid Perfect Square.java	
@@ -1,11 +1,22 @@
 class Solution {
-    public boolean isPerfectSquare(int num) {
-        int i = 1;
-        while(num > 0) {
-            num -= i;
-            i += 2;
-        }
-        
-        return num == 0;
+  public boolean isPerfectSquare(int num) {
+    return binarySearchHelper((long)1, (long)num, num) == -1 ? false : true;
+  }
+  
+  private int binarySearchHelper(long start, long end, int num) {
+    while (start <= end) {
+      long mid = (start + end) / 2;
+      long square = (long) Math.pow(mid, 2);
+      if (square == num) {
+        return (int) mid;
+      }
+      else if (square > num) {
+        end = mid - 1;
+      }
+      else {
+        start = mid + 1;
+      }
     }
+    return -1;
+  }
 }
diff --git a/Medium/Count Square Submatrices with All Ones.java b/Medium/Count Square Submatrices with All Ones.java
new file mode 100644
index 00000000..03e98e58
--- /dev/null
+++ b/Medium/Count Square Submatrices with All Ones.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int countSquares(int[][] matrix) {
+    int ans = 0;
+    for (int i = 0; i < matrix.length; i++) {
+      for (int j = 0; j < matrix[i].length; j++) {
+        if (matrix[i][j] > 0 && i > 0 && j > 0) {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1], Math.min(matrix[i - 1][j], matrix[i][j - 1])
+          ) + 1;
+        }
+        ans += matrix[i][j];
+      }
+    }
+    return ans;
+  }
+}

From d402c14fc32977b23ba4faf34f2e27258a038b2f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 10 May 2020 10:01:33 -0700
Subject: [PATCH 0165/2175] Added 2 solutions

---
 .../Build an Array With Stack Operations.java | 20 +++++++++++++++++++
 Medium/Find the Town Judge.java               | 15 ++++++++++++++
 2 files changed, 35 insertions(+)
 create mode 100644 Easy/Build an Array With Stack Operations.java
 create mode 100644 Medium/Find the Town Judge.java

diff --git a/Easy/Build an Array With Stack Operations.java b/Easy/Build an Array With Stack Operations.java
new file mode 100644
index 00000000..c3a57156
--- /dev/null
+++ b/Easy/Build an Array With Stack Operations.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public List<String> buildArray(int[] target, int n) {
+    List<String> ans = new ArrayList<>();
+    final String PUSH = "Push";
+    final String POP = "Pop";
+    int idx = 0;
+    int curr = 1;
+    while (idx < target.length) {
+      ans.add(PUSH);
+      if (target[idx] == curr) {
+        idx++;
+      }
+      else {
+        ans.add(POP);
+      }
+      curr++;
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Find the Town Judge.java b/Medium/Find the Town Judge.java
new file mode 100644
index 00000000..e8597e29
--- /dev/null
+++ b/Medium/Find the Town Judge.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int findJudge(int N, int[][] trust) {
+    int[] trustScore = new int[N + 1];
+    for (int[] trst : trust) {
+      trustScore[trst[0]]--;
+      trustScore[trst[1]]++;
+    }
+    for (int i = 1; i <= N; i++) {
+      if (trustScore[i] == (N - 1)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}

From ce3caddf17c4dc76b91761f28a767bc1fbede0c2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 11 May 2020 13:53:38 -0700
Subject: [PATCH 0166/2175] Added Time Needed to Inform All Employees.java

---
 .../Time Needed to Inform All Employees.java  | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Time Needed to Inform All Employees.java

diff --git a/Medium/Time Needed to Inform All Employees.java b/Medium/Time Needed to Inform All Employees.java
new file mode 100644
index 00000000..901f53b5
--- /dev/null
+++ b/Medium/Time Needed to Inform All Employees.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
+    Map<Integer, List<Integer>> organization = new HashMap<>();
+    for (int i = 0; i < manager.length; i++) {
+      if (manager[i] != -1) {
+        organization.computeIfAbsent(manager[i], k -> new ArrayList<>()).add(i);
+      }
+    }
+    int totalTime = 0;
+    Queue<int[]> queue = new LinkedList<>();
+    queue.add(new int[]{headID, 0});
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int id = removed[0]; 
+      int time = removed[1]; 
+      totalTime = Math.max(totalTime, time);
+      for (int associate : organization.getOrDefault(id, new ArrayList<>())) {
+        queue.add(new int[]{associate, time + informTime[id]});
+      }
+    }
+    return totalTime;
+  }
+}

From 1d52a20adf7b54ffe57eb2a407883e819c05d4ac Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 12 May 2020 20:33:42 -0700
Subject: [PATCH 0167/2175] Added 1 solution & modified 1 solution

---
 Easy/Largest Time for Given Digits.java | 25 ++++++++++
 Medium/Hand of Straights.java           | 62 ++++++++++---------------
 2 files changed, 50 insertions(+), 37 deletions(-)
 create mode 100644 Easy/Largest Time for Given Digits.java

diff --git a/Easy/Largest Time for Given Digits.java b/Easy/Largest Time for Given Digits.java
new file mode 100644
index 00000000..1f57f8a5
--- /dev/null
+++ b/Easy/Largest Time for Given Digits.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public String largestTimeFromDigits(int[] A) {
+    int ans = -1;
+    // Choose different indices i, j, k, l as a permutation of 0, 1, 2, 3
+    for (int i = 0; i < 4; ++i) {
+      for (int j = 0; j < 4; ++j) {
+        if (j != i) {
+          for (int k = 0; k < 4; ++k) {
+            if (k != i && k != j) {
+              int l = 6 - i - j - k;
+              // For each permutation of A[i], read out the time and
+              // record the largest legal time.
+              int hours = 10 * A[i] + A[j];
+              int mins = 10 * A[k] + A[l];
+              if (hours < 24 && mins < 60) {
+                ans = Math.max(ans, hours * 60 + mins);
+              }
+            }
+          }
+        }
+      }
+    }
+    return ans >= 0 ? String.format("%02d:%02d", ans / 60, ans % 60) : "";
+  }
+}
diff --git a/Medium/Hand of Straights.java b/Medium/Hand of Straights.java
index 21675476..ceff444a 100644
--- a/Medium/Hand of Straights.java	
+++ b/Medium/Hand of Straights.java	
@@ -1,41 +1,29 @@
 class Solution {
-    public static boolean isNStraightHand(int[] hand, int W) {
-        if (hand.length%W != 0) {
-            return false;
-        }
-
-        Map<Integer, Integer> map = new TreeMap<>();
-
-        for (int num : hand) {
-            map.put(num, map.getOrDefault(num, 0)+1);
-        }
-
-        Set<Integer> keys;
-        int batches = hand.length/W;
-        int batchSize;
-
-        while (batches-- > 0) {
-            keys = map.keySet();
-            Iterator<Integer> iterator = keys.iterator();
-            batchSize = W;
-            int val = iterator.next();
-
-            while (batchSize-- > 0) {
-                if (map.containsKey(val)) {
-                    if (map.get(val) == 1) {
-                        map.remove(val);
-                    }
-                    else {
-                        map.put(val, map.getOrDefault(val, 0)-1);
-                    }
-                    val++;
-                }
-                else {
-                    return false;
-                }
-            }
+  public boolean isNStraightHand(int[] hand, int W) {
+    if (hand.length % W != 0) {
+      return false;
+    }
+    Map<Integer, Integer> counterMap = new HashMap<>();
+    Set<Integer> set = new TreeSet<>();
+    for (int num : hand) {
+      counterMap.put(num, counterMap.getOrDefault(num, 0) + 1);
+      set.add(num);
+    }
+    Iterator<Integer> iter = set.iterator();
+    Integer curr = iter.next();
+    while (counterMap.get(curr) > 0) {
+      int temp = curr;
+      for (int i = 0; i < W; i++) {
+        if (counterMap.getOrDefault(temp, 0) == 0) {
+          return false;
         }
-
-        return true;
+        counterMap.put(temp, counterMap.get(temp) - 1);
+        temp++;
+      }
+      while (iter.hasNext() && counterMap.get(curr) == 0) {
+        curr = iter.next();
+      }
     }
+    return true;
+  }
 }

From f95ae71489ba07f9deeff0a24e43201c78997c24 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 18 May 2020 10:37:19 -0500
Subject: [PATCH 0168/2175] Added Consecutive Characters.java

---
 Easy/Consecutive Characters.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Consecutive Characters.java

diff --git a/Easy/Consecutive Characters.java b/Easy/Consecutive Characters.java
new file mode 100644
index 00000000..cb37c58b
--- /dev/null
+++ b/Easy/Consecutive Characters.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int maxPower(String s) {
+    int count = 0;
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      char c = s.charAt(idx);
+      int tempCount = 0;
+      while (idx < n && s.charAt(idx) == c) {
+        idx++;
+        tempCount++;
+      }
+      count = Math.max(count, tempCount);
+    }
+    return count;
+  }
+}

From 811d67652c023396600225b3c4d2506d110b488a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 22 May 2020 08:57:27 -0500
Subject: [PATCH 0169/2175] Modified Online Stock Span.java

---
 Medium/Online Stock Span.java | 33 +++++++++++++++------------------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/Medium/Online Stock Span.java b/Medium/Online Stock Span.java
index caad4a18..9f30c4fd 100644
--- a/Medium/Online Stock Span.java	
+++ b/Medium/Online Stock Span.java	
@@ -1,24 +1,21 @@
 class StockSpanner {
-    Stack<Integer> prices;
-    Stack<Integer> weights;
+  Stack<Integer> stack;
+  Stack<Integer> occurences;
+  public StockSpanner() {
+    stack = new Stack<>();
+    occurences = new Stack<>();
+  }
 
-    public StockSpanner() {
-        prices = new Stack();
-        weights = new Stack();
-    }
-
-    public int next(int price) {
-        int w = 1;
-        while (!prices.isEmpty() && prices.peek() <= price) {
-            prices.pop();
-            w += weights.pop();
-        }
-
-        prices.push(price);
-        weights.push(w);
-        
-        return w;
+  public int next(int price) {
+    int count = 1;
+    while (!stack.isEmpty() && stack.peek() <= price) {
+      stack.pop();
+      count += occurences.pop();
     }
+    stack.push(price);
+    occurences.push(count);
+    return count;
+  }
 }
 
 /**

From 4b2941242b01f700b0f346773ed956851e1443c3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 25 May 2020 13:57:30 -0500
Subject: [PATCH 0170/2175] Added 1 solution

---
 ...As a Prefix of Any Word in a Sentence.java | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 Easy/Check If a Word Occurs As a Prefix of Any Word in a Sentence.java

diff --git a/Easy/Check If a Word Occurs As a Prefix of Any Word in a Sentence.java b/Easy/Check If a Word Occurs As a Prefix of Any Word in a Sentence.java
new file mode 100644
index 00000000..5948c716
--- /dev/null
+++ b/Easy/Check If a Word Occurs As a Prefix of Any Word in a Sentence.java	
@@ -0,0 +1,52 @@
+class Solution {
+  public int isPrefixOfWord(String sentence, String searchWord) {
+    Node root = new Node('-');
+    String[] words = sentence.split("\\s+");
+    Map<String, Integer> indexMap = new HashMap<>();
+    for (int i = 0; i< words.length; i++) {
+      addWord(words[i], root, 0);
+      if (!indexMap.containsKey(words[i])) {
+        indexMap.put(words[i], i + 1);
+      }
+    }
+    for (int i = 0; i < searchWord.length(); i++) {
+      char c = searchWord.charAt(i);
+      if (!root.map.containsKey(c)) {
+        return -1;
+      }
+      root = root.map.get(c);
+    }
+    PriorityQueue<String> pq = new PriorityQueue<>(new Comparator<String>(){
+      public int compare(String s1, String s2) {
+        return indexMap.get(s1) - indexMap.get(s2);
+      }
+    });
+    pq.addAll(root.words);
+    return indexMap.get(pq.poll());
+  }
+  
+  private void addWord(String s, Node root, int idx) {
+    if (idx == s.length()) {
+      return;
+    }
+    char c = s.charAt(idx);
+    if (!root.map.containsKey(c)) {
+      root.map.put(c, new Node(c));
+    }
+    Node next = root.map.get(c);
+    next.words.add(s);
+    addWord(s, next, idx + 1);
+  }
+}
+
+class Node {
+  char c;
+  Map<Character, Node> map;
+  Set<String> words;
+  
+  public Node(char c) {
+    this.c = c;
+    map = new HashMap<>();
+    words = new HashSet<>();
+  }
+}

From f977fa6394e8e93218e5c91bee1e39b478729a1d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 25 May 2020 18:59:12 -0500
Subject: [PATCH 0171/2175] Added Maximum Number of Vowels in a Substring of
 Given Length.java

---
 ...Vowels in a Substring of Given Length.java | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Maximum Number of Vowels in a Substring of Given Length.java

diff --git a/Medium/Maximum Number of Vowels in a Substring of Given Length.java b/Medium/Maximum Number of Vowels in a Substring of Given Length.java
new file mode 100644
index 00000000..5af78c54
--- /dev/null
+++ b/Medium/Maximum Number of Vowels in a Substring of Given Length.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public int maxVowels(String s, int k) {
+    Map<Character, Integer> map = new HashMap<>();
+    String vowels = "aeiou";
+    int count = 0;
+    int maxCount = 0;
+    int start = 0;
+    int end = 0;
+    int n = s.length();
+    while (end < (k - 1)) {
+      if (vowels.indexOf(s.charAt(end)) != -1) {
+        map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+        count++;
+      }
+      end++;
+    }
+    while (end < n) {
+       if (vowels.indexOf(s.charAt(end)) != -1) {
+        map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+         count++;
+      }
+      end++;
+      maxCount = Math.max(maxCount, count);
+      if (vowels.indexOf(s.charAt(start)) != -1) {
+        map.put(s.charAt(start), map.getOrDefault(s.charAt(start), 0) - 1);
+        count--;
+      }
+      start++;
+    }
+    return maxCount;
+  }
+}

From 3be318840c5289681ae6abaa874f9c4ca1cb1c36 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 26 May 2020 18:19:03 -0500
Subject: [PATCH 0172/2175] Modified Two City Scheduling.java

---
 Easy/Two City Scheduling.java | 31 ++++++++++++-------------------
 1 file changed, 12 insertions(+), 19 deletions(-)

diff --git a/Easy/Two City Scheduling.java b/Easy/Two City Scheduling.java
index 8d7a6255..6bcb5602 100644
--- a/Easy/Two City Scheduling.java	
+++ b/Easy/Two City Scheduling.java	
@@ -1,22 +1,15 @@
 class Solution {
-    public int twoCitySchedCost(int[][] costs) {
-        Arrays.sort(costs, new Comparator<int[]>() {
-            @Override
-            public int compare(int[] o1, int[] o2) {
-                return o1[0] - o1[1] - (o2[0] - o2[1]);
-            }
-        });
-
-        int total = 0;
-        for (int i = 0; i < costs.length; i++) {
-            if (i < costs.length / 2) {
-                total += costs[i][0];
-            }
-            else {
-                total += costs[i][1];
-            }
-        }
-        
-        return total;
+  public int twoCitySchedCost(int[][] costs) {
+    Arrays.sort(costs, new Comparator<int[]>(){
+      public int compare(int[] o1, int[] o2) {
+       return o1[0] - o1[1] - (o2[0] - o2[1]); 
+      }
+    });
+    int total = 0;
+    int n = costs.length / 2;
+    for (int i = 0; i < n; i++) {
+      total += costs[i][0] + costs[i + n][1];
     }
+    return total;
+  }
 }

From 9fd78fb1bca83d722488bac0e37504f32096b62c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 28 May 2020 16:24:35 -0500
Subject: [PATCH 0173/2175] Modified Top K Frequent Elements.java

---
 Medium/Top K Frequent Elements.java | 65 +++++++++--------------------
 1 file changed, 20 insertions(+), 45 deletions(-)

diff --git a/Medium/Top K Frequent Elements.java b/Medium/Top K Frequent Elements.java
index 918a9006..f3f6ae2d 100644
--- a/Medium/Top K Frequent Elements.java	
+++ b/Medium/Top K Frequent Elements.java	
@@ -1,49 +1,24 @@
 class Solution {
-
-    public List<Integer> topKFrequent(int[] nums, int k) {
-        Map<Integer, Integer> map = new HashMap<>();
-
-        for (int i=0;i<nums.length;i++) {
-            if (map.containsKey(nums[i])) {
-                map.put(nums[i], map.get(nums[i])+1);
-            }
-            else {
-                map.put(nums[i], 1);
-            }
-        }
-        
-        Map<Integer, Integer> sortedMap = sortByValue(map);
-        
-        List<Integer> ans = new ArrayList<>();
-        int c = 0;
-        
-        for (Map.Entry<Integer,Integer> entry : sortedMap.entrySet()) {
-            if (c == k) break;
-            ans.add(entry.getKey());
-            
-            c++;
-        }
-        
-        return ans;
+  public int[] topKFrequent(int[] nums, int k) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
     }
-    
-    private Map<Integer, Integer> sortByValue(Map<Integer, Integer> unsortMap) {
-
-        List<Map.Entry<Integer, Integer>> list =
-                new LinkedList<Map.Entry<Integer, Integer>>(unsortMap.entrySet());
-
-        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
-            public int compare(Map.Entry<Integer, Integer> o1,
-                               Map.Entry<Integer, Integer> o2) {
-                return (o2.getValue()).compareTo(o1.getValue());
-            }
-        });
-
-        Map<Integer, Integer> sortedMap = new LinkedHashMap<Integer, Integer>();
-        for (Map.Entry<Integer, Integer> entry : list) {
-            sortedMap.put(entry.getKey(), entry.getValue());
-        }
-
-        return sortedMap;
+    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
+      public int compare(Integer p1, Integer p2) {
+        return map.get(p1) - map.get(p2);
+      }
+    });
+    for (Integer key : map.keySet()) {
+      pq.add(key);
+      if (pq.size() > k) {
+        pq.poll();
+      }
     }
+    int[] ans = new int[k];
+    for (int i = 0; i < k; i++) {
+      ans[i] = pq.poll();
+    }
+    return ans;
+  }
 }

From 2f82abd5008e0796f74aaa1db2d873ed1f8c5f14 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 31 May 2020 10:30:55 -0500
Subject: [PATCH 0174/2175] Added Maximum Product of Two Elements in an
 Array.java

---
 ...imum Product of Two Elements in an Array.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Maximum Product of Two Elements in an Array.java

diff --git a/Easy/Maximum Product of Two Elements in an Array.java b/Easy/Maximum Product of Two Elements in an Array.java
new file mode 100644
index 00000000..afc4e858
--- /dev/null
+++ b/Easy/Maximum Product of Two Elements in an Array.java	
@@ -0,0 +1,16 @@
+class Solution {
+  int maxOne = Integer.MIN_VALUE;
+  int maxTwo = Integer.MIN_VALUE;
+  public int maxProduct(int[] nums) {
+    for (int num : nums) {
+      if (maxOne < num) {
+        maxTwo = maxOne;
+        maxOne = num;
+      }
+      else if (maxTwo < num) {
+        maxTwo = num;
+      }
+    }
+    return (maxOne - 1) * (maxTwo - 1);
+  }
+}

From e99a2e7daa319b76bda484ba06ab94732423006f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 1 Jun 2020 17:44:57 -0500
Subject: [PATCH 0175/2175] Modified 2 solutions

---
 Easy/Range Sum Query_Immutable.java | 28 ++++++++--------
 Medium/Course Schedule.java         | 51 ++++++++++++++---------------
 2 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/Easy/Range Sum Query_Immutable.java b/Easy/Range Sum Query_Immutable.java
index 14c50db7..38beec52 100644
--- a/Easy/Range Sum Query_Immutable.java	
+++ b/Easy/Range Sum Query_Immutable.java	
@@ -1,20 +1,22 @@
 class NumArray {
-    int[] nums;
-
-    public NumArray(int[] nums) {
-        for(int i = 1; i < nums.length; i++)
-            nums[i] += nums[i - 1];
-
-        this.nums = nums;
+  int[] rangeSum;
+  public NumArray(int[] nums) {
+    rangeSum = new int[nums.length];
+    int sum = 0;
+    for (int i = 0; i < nums.length; i++) {
+      sum += nums[i];
+      rangeSum[i] = sum;
     }
+  }
 
-    public int sumRange(int i, int j) {
-        if(i == 0)
-            return nums[j];
-
-        return nums[j] - nums[i - 1];
+  public int sumRange(int i, int j) {
+    int currSum = rangeSum[j];
+    int endIdx = i - 1;
+    if (endIdx >= 0) {
+      currSum -= rangeSum[endIdx];
     }
-
+    return currSum;
+  }
 }
 
 /**
diff --git a/Medium/Course Schedule.java b/Medium/Course Schedule.java
index 5d651ec9..b1eadebb 100644
--- a/Medium/Course Schedule.java	
+++ b/Medium/Course Schedule.java	
@@ -1,31 +1,28 @@
 class Solution {
-    Set<Integer> set = new HashSet<>();
-    public boolean canFinish(int numCourses, int[][] prerequisites) {
-        Map<Integer, Set<Integer>> map = new HashMap<>();
-        for (int[] prereq : prerequisites) {
-            map.computeIfAbsent(prereq[0], k -> new HashSet<>()).add(prereq[1]);
-        }
-        
-        for (int i = 0; i < numCourses; i++) {
-            set.clear();
-            dfsHelper(map, i);
-            
-            if (set.contains(i)) {
-                return false;
-            }
-        }
-        
-        return true;
+  Set<Integer> set = new HashSet<>();
+  public boolean canFinish(int numCourses, int[][] prerequisites) {
+    Map<Integer, Set<Integer>> map = new HashMap<>();
+    for (int[] prerequisite : prerequisites) {
+      map.computeIfAbsent(prerequisite[0], k -> new HashSet<>()).add(prerequisite[1]);
     }
-    
-    private void dfsHelper(Map<Integer, Set<Integer>> map, int courseNum) {
-        Iterator<Integer> iterator = map.getOrDefault(courseNum, new HashSet<>()).iterator();
-        while (iterator.hasNext()) {
-            int course = iterator.next();
-            if (!set.contains(course)) {
-                set.add(course);
-                dfsHelper(map, course);
-            }
-        }
+    for (int i = 0; i < numCourses; i++) {
+      set.clear();
+      dfs(map, i);
+      if (set.contains(i)) {
+        return false;
+      }
     }
+    return true;
+  }
+  
+  private void dfs(Map<Integer, Set<Integer>> map, int num) {
+    Iterator<Integer> iter = map.getOrDefault(num, new HashSet<>()).iterator();
+    while (iter.hasNext()) {
+      int course = iter.next();
+      if (!set.contains(course)) {
+        set.add(course);
+        dfs(map, course);
+      }
+    }
+  }
 }

From 3879960a1783c5b960ba41bb238cdd115829e893 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 3 Jun 2020 11:46:07 -0500
Subject: [PATCH 0176/2175] Added Count Good Nodes in Binary Tree.java

---
 Medium/Count Good Nodes in Binary Tree.java | 33 +++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 Medium/Count Good Nodes in Binary Tree.java

diff --git a/Medium/Count Good Nodes in Binary Tree.java b/Medium/Count Good Nodes in Binary Tree.java
new file mode 100644
index 00000000..e5f87685
--- /dev/null
+++ b/Medium/Count Good Nodes in Binary Tree.java	
@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int goodNodes(TreeNode root) {
+    int[] count = {0};
+    helper(root, root.val, count);
+    return count[0];
+  }
+  
+  private void helper(TreeNode root, int currMax, int[] count) {
+    if (root == null) {
+      return;
+    }
+    if (root.val >= currMax) {
+      count[0]++;
+    }
+    helper(root.left, Math.max(currMax, root.val), count);
+    helper(root.right, Math.max(currMax, root.val), count);
+  }
+}

From 0ca5ca9484b502870ba4060b5b44c872089669c1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 3 Jun 2020 21:04:51 -0500
Subject: [PATCH 0177/2175] Added 1 solution & modified 1 solution

---
 Easy/Find All the Lonely Nodes.java | 33 +++++++++++++++++++++++++++++
 Easy/Path Sum III.java              | 22 +++++++++----------
 2 files changed, 44 insertions(+), 11 deletions(-)
 create mode 100644 Easy/Find All the Lonely Nodes.java

diff --git a/Easy/Find All the Lonely Nodes.java b/Easy/Find All the Lonely Nodes.java
new file mode 100644
index 00000000..369cf65f
--- /dev/null
+++ b/Easy/Find All the Lonely Nodes.java	
@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public List<Integer> getLonelyNodes(TreeNode root) {
+    List<Integer> list = new ArrayList<>();
+    helper(root, null, list);
+    return list;
+  }
+  
+  private void helper(TreeNode node, TreeNode parent, List<Integer> list) {
+    if (node == null) {
+      return;
+    }
+    if (parent != null && ((parent.left != null && parent.right == null) || (parent.right != null && parent.left == null))) {
+      list.add(node.val);
+    }
+    helper(node.left, node, list);
+    helper(node.right, node, list);
+  }
+}
diff --git a/Easy/Path Sum III.java b/Easy/Path Sum III.java
index 03bdaa77..08c0fd85 100644
--- a/Easy/Path Sum III.java	
+++ b/Easy/Path Sum III.java	
@@ -8,17 +8,17 @@
  * }
  */
 class Solution {
-    public int pathSum(TreeNode root, int sum) {
-        if(root == null) {
-            return 0;
-        }
-        
-        return pathSumFrom(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
+  public int pathSum(TreeNode root, int sum) {
+    if (root == null) {
+      return 0;
     }
-    
-    private int pathSumFrom(TreeNode root, int sum) {
-        if (root == null) return 0;
-        
-        return (root.val ==  sum ? 1 : 0) + pathSumFrom(root.left, sum - root.val) + pathSumFrom(root.right, sum - root.val); 
+    return helper(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
+  }
+  
+  private int helper(TreeNode root, int sum) {
+    if (root == null) {
+      return 0;
     }
+    return (root.val == sum ? 1 : 0) + helper(root.left, sum - root.val) +  helper(root.right, sum - root.val);
+  }
 }

From 95b58b325f73a3e288465d17371f788a0a8ddbf2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 4 Jun 2020 17:29:20 -0500
Subject: [PATCH 0178/2175] Modified 2 solutions

---
 Easy/House Robber.java   | 28 +++++++++-------------------
 Easy/Reverse String.java | 19 ++++++++++++-------
 2 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/Easy/House Robber.java b/Easy/House Robber.java
index cbef9ca9..6dc13216 100644
--- a/Easy/House Robber.java	
+++ b/Easy/House Robber.java	
@@ -1,22 +1,12 @@
 class Solution {
-    public int rob(int[] nums) {
-        int[] dp = new int[nums.length];
-        Arrays.fill(dp, -1);
-        
-        return robImpl(nums, 0, dp);
-    }
-    
-    private int robImpl(int[] nums, int start, int[] dp) {
-        if (start > nums.length-1) {
-            return 0;
-        }
-        
-        if (dp[start] != -1) {
-            return dp[start];
-        }
-        
-        dp[start] = Math.max(nums[start] + robImpl(nums, start+2, dp), robImpl(nums, start+1, dp));
-        
-        return dp[start];
+  public int rob(int[] nums) {
+    int prev = 0;
+    int curr = 0;
+    for (int num : nums) {
+      int temp = curr;
+      curr = Math.max(prev + num, curr);
+      prev = temp;
     }
+    return curr;
+  }
 }
diff --git a/Easy/Reverse String.java b/Easy/Reverse String.java
index 18a51725..28dfed23 100644
--- a/Easy/Reverse String.java	
+++ b/Easy/Reverse String.java	
@@ -1,8 +1,13 @@
-public class Solution {
-    public String reverseString(String s) {
-        StringBuilder input1 = new StringBuilder();
-        input1.append(s);
-        input1 = input1.reverse();
-        return input1.toString();
+class Solution {
+  public void reverseString(char[] s) {
+    int start = 0;
+    int end = s.length - 1;
+    while (start < end) {
+      char temp = s[start];
+      s[start] = s[end];
+      s[end] = temp;
+      start++;
+      end--;
     }
-}
\ No newline at end of file
+  }
+}

From 742dd93e770d807377354c1e318447bd38f4c548 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 6 Jun 2020 15:39:42 -0500
Subject: [PATCH 0179/2175] Modified 3 solutions

---
 Easy/Construct String from Binary Tree.java | 48 +++++++++++--------
 Medium/Queue Reconstruction By Height.java  | 31 +++++++------
 Medium/Random Pick With Weight.java         | 51 ++++++++-------------
 3 files changed, 63 insertions(+), 67 deletions(-)

diff --git a/Easy/Construct String from Binary Tree.java b/Easy/Construct String from Binary Tree.java
index 64c762a2..be38ff5e 100644
--- a/Easy/Construct String from Binary Tree.java	
+++ b/Easy/Construct String from Binary Tree.java	
@@ -4,29 +4,37 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public String tree2str(TreeNode t) {
-        StringBuilder sb = new StringBuilder();
-        helper(sb,t);
-        return sb.toString();
+  public String tree2str(TreeNode t) {
+    StringBuilder sb = new StringBuilder();
+    helper(t, sb);
+    return sb.toString();
+  }
+  
+  private void helper(TreeNode node, StringBuilder sb) {
+    if (node == null) {
+      return;
     }
-    
-    public void helper(StringBuilder sb,TreeNode t){
-        if(t!=null){
-            sb.append(t.val);
-            if(t.left!=null||t.right!=null){
-                sb.append("(");
-                helper(sb,t.left);
-                sb.append(")");
-                if(t.right!=null){
-                    sb.append("(");
-                helper(sb,t.right);
-                sb.append(")");
-                }
-            }
-        }
+    sb.append(node.val);
+    if (node.left == null && node.right == null) {
+      return;
     }
+    sb.append("(");
+    helper(node.left, sb);
+    sb.append(")");
+    if (node.right != null) {
+      sb.append("(");
+      helper(node.right, sb);
+      sb.append(")");
+    }
+  }
 }
diff --git a/Medium/Queue Reconstruction By Height.java b/Medium/Queue Reconstruction By Height.java
index 79279acf..5314da67 100644
--- a/Medium/Queue Reconstruction By Height.java	
+++ b/Medium/Queue Reconstruction By Height.java	
@@ -1,19 +1,20 @@
 class Solution {
-    public int[][] reconstructQueue(int[][] people) {
-        
-        Arrays.sort(people,new Comparator<int[]>(){
-           @Override
-           public int compare(int[] o1, int[] o2){
-               return o1[0]!=o2[0]?-o1[0]+o2[0]:o1[1]-o2[1];
-           }
-        });
-        
-        List<int[]> res = new LinkedList<>();
-        for(int[] cur : people){
-            res.add(cur[1],cur);       
+  public int[][] reconstructQueue(int[][] people) {
+    Arrays.sort(people, new Comparator<int[]>(){
+      public int compare(int[] o1, int[] o2) {
+        int c = o2[0] - o1[0];
+        if (c != 0) {
+          return c;
         }
-        
-        return res.toArray(new int[people.length][]);
-        
+        return o1[1] - o2[1]; 
+      }
+    });
+    System.out.println();
+    List<int[]> list = new ArrayList<>();
+    for (int[] p : people) {
+      list.add(p[1], p);
     }
+    int n = people.length;
+    return list.toArray(new int[n][2]);
+  }
 }
diff --git a/Medium/Random Pick With Weight.java b/Medium/Random Pick With Weight.java
index 98cea2b9..3d3546fa 100644
--- a/Medium/Random Pick With Weight.java	
+++ b/Medium/Random Pick With Weight.java	
@@ -1,38 +1,25 @@
 class Solution {
-
-    int[] accumulatedSum;
-    Random random;
-    public Solution(int[] w) {
-        random = new Random();
-        accumulatedSum = new int[w.length];
-        int currSum = 0;
-        for (int i = 0; i < w.length; i++) {
-            currSum += w[i];
-            accumulatedSum[i] = currSum;
-        }
-    }
-    
-    public int pickIndex() {
-        int target = random.nextInt(accumulatedSum[accumulatedSum.length - 1]) + 1;
-        return binarySearch(accumulatedSum, 0, accumulatedSum.length - 1, target);
+  int[] arr;
+  int counter = 0;
+  Random r = new Random();
+  public Solution(int[] w) {
+    arr = new int[w.length];
+    counter += w[0];
+    arr[0] = w[0];
+    for (int i = 1; i < w.length; i++) {
+      arr[i] = arr[i - 1] + w[i];
+      counter += w[i];
     }
-    
-    private int binarySearch(int[] arr, int left, int right, int target) {
-        while (left <= right) {
-            int mid = (left + right) / 2;
-            if (arr[mid] == target) {
-                return mid;
-            }
-            else if (arr[mid] > target) {
-                right = mid - 1;
-            }
-            else {
-                left = mid + 1;
-            }
-        }
-        
-        return left;
+  }
+
+  public int pickIndex() {
+    int idx = r.nextInt(counter) + 1;
+    int ret = Arrays.binarySearch(arr, idx); 
+    if(ret < 0) {
+      ret = -ret - 1;
     }
+    return ret;
+  }
 }
 
 /**

From 7e08e87496603b9c9fb381ec469432d0abc669f7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 7 Jun 2020 09:36:08 -0500
Subject: [PATCH 0180/2175] Added 2 solutions & modified 3 solutions

---
 Easy/Binary Tree Tilt.java                    | 35 ++++++++------
 Easy/Minimum  Absolute Difference in BST.java | 44 +++++++++--------
 Easy/Minimum Distance Between BST Nodes.java  | 48 ++++++++++---------
 Easy/Shuffle the Array.java                   | 10 ++++
 .../The k Strongest Values in an Array.java   | 14 ++++++
 5 files changed, 96 insertions(+), 55 deletions(-)
 create mode 100644 Easy/Shuffle the Array.java
 create mode 100644 Medium/The k Strongest Values in an Array.java

diff --git a/Easy/Binary Tree Tilt.java b/Easy/Binary Tree Tilt.java
index e4f8ad0a..48a6c409 100644
--- a/Easy/Binary Tree Tilt.java	
+++ b/Easy/Binary Tree Tilt.java	
@@ -4,22 +4,29 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int findTilt(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        return Math.abs(sum(root.left) - sum(root.right)) + findTilt(root.right) + findTilt(root.left);
-    }
-    
-    
-    public int sum(TreeNode root) {
-        if(root == null) {
-            return 0;
-        }
-        return root.val + sum(root.left) + sum(root.right);
+  public int findTilt(TreeNode root) {
+    int[] total = {0};
+    helper(root, total);
+    return total[0];
+  }
+  
+  private int helper(TreeNode root, int[] total) {
+    if (root == null) {
+      return 0;
     }
+    int left = helper(root.left, total);
+    int right = helper(root.right, total);
+    total[0] += Math.abs(left - right);
+    return left + right + root.val;
+  }
 }
diff --git a/Easy/Minimum  Absolute Difference in BST.java b/Easy/Minimum  Absolute Difference in BST.java
index 9d87b1df..d29da542 100644
--- a/Easy/Minimum  Absolute Difference in BST.java	
+++ b/Easy/Minimum  Absolute Difference in BST.java	
@@ -4,28 +4,34 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    ArrayList<Integer> values = new ArrayList<>();
-    public int getMinimumDifference(TreeNode root) {
-        inOrder(root);
-        
-        int min = Integer.MAX_VALUE;
-        for (int i=1;i<values.size();i++) {
-            min = Math.min(min, Math.abs(values.get(i)-values.get(i-1)));
-        }
-        
-        return min;
+  int minDiff;
+  TreeNode prev;
+  public int getMinimumDifference(TreeNode root) {
+    minDiff = Integer.MAX_VALUE;
+    prev = null;
+    helper(root);
+    return minDiff;
+  }
+  
+  private void helper(TreeNode root) {
+    if (root == null) {
+      return;
     }
-    
-    public void inOrder(TreeNode root) {
-        if (root == null) {
-            return;
-        }
-        inOrder(root.left);
-        values.add(root.val);
-        inOrder(root.right);
+    helper(root.left);
+    if (prev != null) {
+      minDiff = Math.min(minDiff, Math.abs(root.val - prev.val));
     }
+    prev = root;
+    helper(root.right);
+  }
 }
diff --git a/Easy/Minimum Distance Between BST Nodes.java b/Easy/Minimum Distance Between BST Nodes.java
index 00f91729..4c147e39 100644
--- a/Easy/Minimum Distance Between BST Nodes.java	
+++ b/Easy/Minimum Distance Between BST Nodes.java	
@@ -4,31 +4,35 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    
-    int t = Integer.MAX_VALUE;
-    int prev = Integer.MAX_VALUE;
-    
-    public int minDiffInBST(TreeNode root) {
-        inorder(root);
-        
-        return t;
+  Integer minDiff;
+  Integer prev;
+  public int minDiffInBST(TreeNode root) {
+    minDiff = Integer.MAX_VALUE;
+    prev = null;
+    helper(root);
+    return minDiff;
+  }
+  
+  private void helper(TreeNode root) {
+    if (root == null) {
+      return;
     }
-    
-    public void inorder(TreeNode root) {
-        if (root == null) {
-            return;
-        }
-        
-        inorder(root.left);
-        if (prev != Integer.MAX_VALUE) {
-            t = Math.min(t, Math.abs(root.val - prev));
-        }
-        
-        prev = root.val;
-        inorder(root.right);
+    helper(root.left);
+    if (prev != null) {
+      minDiff = Math.min(minDiff, root.val - prev);
     }
+    prev = root.val;
+    helper(root.right);
+  }
 }
+
diff --git a/Easy/Shuffle the Array.java b/Easy/Shuffle the Array.java
new file mode 100644
index 00000000..0acc657c
--- /dev/null
+++ b/Easy/Shuffle the Array.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public int[] shuffle(int[] nums, int n) {
+    int[] ans = new int[2 * n];
+    for (int i = 0; i < n; i++) {
+      ans[2 * i] = nums[i];
+      ans[2 * i + 1] = nums[n + i];
+    }
+    return ans;
+  }
+}
diff --git a/Medium/The k Strongest Values in an Array.java b/Medium/The k Strongest Values in an Array.java
new file mode 100644
index 00000000..1bce4fc2
--- /dev/null
+++ b/Medium/The k Strongest Values in an Array.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int[] getStrongest(int[] arr, int k) {
+    Arrays.sort(arr);
+    int i = 0;
+    int j = arr.length - 1;
+    int idx = 0;
+    int median = arr[(arr.length - 1) / 2];
+    int[] res = new int[k];
+    while (idx < k) {
+      res[idx++] = (median - arr[i] > arr[j] - median) ? arr[i++] : arr[j--];
+    }
+    return res;
+  }
+}

From 08a1f4e6ef64a611958476722fed554288de7da1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 8 Jun 2020 14:18:00 -0500
Subject: [PATCH 0181/2175] Added 1 solution & modified 1 solution

---
 Easy/Power of Two.java             | 23 +++++++++++++++
 Easy/power_of_2.java               | 28 ------------------
 Medium/Design Browser History.java | 47 ++++++++++++++++++++++++++++++
 3 files changed, 70 insertions(+), 28 deletions(-)
 create mode 100644 Easy/Power of Two.java
 delete mode 100644 Easy/power_of_2.java
 create mode 100644 Medium/Design Browser History.java

diff --git a/Easy/Power of Two.java b/Easy/Power of Two.java
new file mode 100644
index 00000000..c4ddd0f3
--- /dev/null
+++ b/Easy/Power of Two.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public boolean isPowerOfTwo(int n) {
+    if (n % 2 != 0 && n != 1) {
+      return false;
+    }
+    int start = 0;
+    int end = n / 2;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      int pow = (int) (Math.pow(2, mid));
+      if (n == pow) {
+        return true;
+      }
+      else if (n > pow) {
+        start = mid + 1;
+      }
+      else {
+        end = mid - 1;
+      }
+    }
+    return false;
+  }
+}
diff --git a/Easy/power_of_2.java b/Easy/power_of_2.java
deleted file mode 100644
index 55421816..00000000
--- a/Easy/power_of_2.java
+++ /dev/null
@@ -1,28 +0,0 @@
-public class Solution {
-    public boolean isPowerOfTwo(int n) {
-        int i=0;
-        int c=0;
-        while(true)
-        {
-        	if(Math.pow(2, i)==n)
-        	{
-        		c=1;
-        		break;
-        	}
-        	else if(Math.pow(2, i)>n)
-        	{
-        		break;
-        	}
-        	i++;
-        }
-        
-        if(c==1)
-        {
-        	return true;
-        }
-        else
-        {
-        	return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Medium/Design Browser History.java b/Medium/Design Browser History.java
new file mode 100644
index 00000000..fb5db3bb
--- /dev/null
+++ b/Medium/Design Browser History.java	
@@ -0,0 +1,47 @@
+class BrowserHistory {
+  
+  Node root;
+  public BrowserHistory(String homepage) {
+    root = new Node(homepage);
+  }
+
+  public void visit(String url) {
+    Node node = new Node(url);
+    root.next = null;
+    root.next = node;
+    node.prev = root;
+    root = root.next;
+  }
+
+  public String back(int steps) {
+    while (steps-- > 0 && root.prev != null) {
+      root = root.prev;
+    }
+    return root.val;
+  }
+
+  public String forward(int steps) {
+    while (steps-- > 0 && root.next != null) {
+      root = root.next;
+    }
+    return root.val;
+  }
+}
+
+class Node {
+  String val;
+  Node next;
+  Node prev;
+  
+  public Node(String val) {
+    this.val = val;
+  }
+}
+
+/**
+ * Your BrowserHistory object will be instantiated and called as such:
+ * BrowserHistory obj = new BrowserHistory(homepage);
+ * obj.visit(url);
+ * String param_2 = obj.back(steps);
+ * String param_3 = obj.forward(steps);
+ */

From f61af8988e1b91483e37512314f57fbc65e5fe70 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 9 Jun 2020 09:51:06 -0500
Subject: [PATCH 0182/2175] Added 2 solutions

---
 Easy/Is Subsequence.java                          | 15 +++++++++++++++
 ...f Students Doing Homework at a Given Time.java | 11 +++++++++++
 2 files changed, 26 insertions(+)
 create mode 100644 Easy/Is Subsequence.java
 create mode 100644 Easy/Number of Students Doing Homework at a Given Time.java

diff --git a/Easy/Is Subsequence.java b/Easy/Is Subsequence.java
new file mode 100644
index 00000000..fc28d621
--- /dev/null
+++ b/Easy/Is Subsequence.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public boolean isSubsequence(String s, String t) {
+    int idxS = 0;
+    int idxT = 0;
+    int lenS = s.length();
+    int lenT = t.length();
+    while (idxS < lenS && idxT < lenT) {
+      if (s.charAt(idxS) == t.charAt(idxT)) {
+        idxS++;
+      }
+      idxT++;
+    }
+    return idxS == lenS;
+  }
+}
diff --git a/Easy/Number of Students Doing Homework at a Given Time.java b/Easy/Number of Students Doing Homework at a Given Time.java
new file mode 100644
index 00000000..9c1f1bd6
--- /dev/null
+++ b/Easy/Number of Students Doing Homework at a Given Time.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int busyStudent(int[] startTime, int[] endTime, int queryTime) {
+    int count = 0;
+    for (int i = 0; i < startTime.length; i++) {
+      if (startTime[i] <= queryTime && endTime[i] >= queryTime) {
+        count++;
+      }
+    }
+    return count;
+  }
+}

From d59672946f0a6ec941da0e1e64eb58c112943391 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 9 Jun 2020 17:56:14 -0500
Subject: [PATCH 0183/2175] Added 1 solution & modified 3 solutions

---
 Easy/Add Digits.java                      | 29 ++++++++++++++++++++++
 Easy/Distribute Candies to People.java    | 21 +++++-----------
 Easy/Number of Lines To Write String.java | 30 +++++++++--------------
 Easy/add_digit.java                       | 21 ----------------
 Medium/Find All Anagrams in a String.java | 30 +++++++++++++++++++++++
 5 files changed, 77 insertions(+), 54 deletions(-)
 create mode 100644 Easy/Add Digits.java
 delete mode 100644 Easy/add_digit.java
 create mode 100644 Medium/Find All Anagrams in a String.java

diff --git a/Easy/Add Digits.java b/Easy/Add Digits.java
new file mode 100644
index 00000000..ab8979b4
--- /dev/null
+++ b/Easy/Add Digits.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int addDigits(int num) {
+    while (isDigitCountGreaterThanOne(num)) {
+      num = getDigitSum(num);
+    }
+    return num;
+  }
+  
+  private int getDigitSum(int num) {
+    int sum = 0;
+    while (num > 0) {
+      sum += num % 10;
+      num /= 10;
+    }
+    return sum;
+  }
+  
+  private boolean isDigitCountGreaterThanOne(int num) {
+    int count = 0;
+    while (num > 0) {
+      num /= 10;
+      count++;
+      if (count > 1) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
diff --git a/Easy/Distribute Candies to People.java b/Easy/Distribute Candies to People.java
index ee8a8fab..a7895dd2 100644
--- a/Easy/Distribute Candies to People.java	
+++ b/Easy/Distribute Candies to People.java	
@@ -1,18 +1,9 @@
 class Solution {
-    public int[] distributeCandies(int candies, int num_people) {
-        int[] count = new int[num_people];
-        int idx = 0;
-        int currCount = 0;
-        int startCandy = 1;
-        
-        while (currCount < candies) {
-            count[idx++] += currCount + startCandy > candies ? candies - currCount : startCandy;
-            currCount += startCandy++;
-            if (idx == num_people) {
-                idx = 0;
-            }
-        }
-        
-        return count;
+  public int[] distributeCandies(int candies, int num_people) {
+    int[] people = new int[num_people];
+    for (int give = 0; candies > 0; candies -= give) {
+      people[give % num_people] +=  Math.min(candies, ++give);
     }
+    return people;
+  }
 }
diff --git a/Easy/Number of Lines To Write String.java b/Easy/Number of Lines To Write String.java
index 488bf839..ca5a50bd 100644
--- a/Easy/Number of Lines To Write String.java	
+++ b/Easy/Number of Lines To Write String.java	
@@ -1,21 +1,15 @@
 class Solution {
-    public static int[] numberOfLines(int[] widths, String S) {
-        if (S.isEmpty()) {
-            return new int[]{0,0};
-        }
-
-        int capacity = 100;
-        char[] chars = S.toCharArray();
-        int count = 1;
-
-        for (char c : chars) {
-            if (capacity - widths[c-'a'] < 0) {
-                capacity = 100;
-                count++;
-            }
-            capacity -= widths[c-'a'];
-        }
-
-        return new int[]{count, 100-capacity};
+  public int[] numberOfLines(int[] widths, String S) {
+    int numOfLines = 1;
+    int currWidth = 0;
+    for (char c : S.toCharArray()) {
+      int width = widths[c - 'a'];
+      currWidth += width;
+      if (currWidth > 100) {
+        numOfLines++;
+        currWidth = width;
+      }
     }
+    return new int[]{numOfLines, currWidth};
+  }
 }
diff --git a/Easy/add_digit.java b/Easy/add_digit.java
deleted file mode 100644
index ee4c9f53..00000000
--- a/Easy/add_digit.java
+++ /dev/null
@@ -1,21 +0,0 @@
-//Solution with running time O(1)
-
-public class Solution {
-    public int addDigits(int num) {
-        if(num!=0)
-        {
-            if(num%9!=0)
-            {
-                return num%9;
-            }
-            else
-            {
-                return 9;
-            }  
-        }
-        else
-        {
-            return 0;
-        }
-    }
-}
diff --git a/Medium/Find All Anagrams in a String.java b/Medium/Find All Anagrams in a String.java
new file mode 100644
index 00000000..1edba8c7
--- /dev/null
+++ b/Medium/Find All Anagrams in a String.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public List<Integer> findAnagrams(String s, String p) {
+    List<Integer> list = new ArrayList<>();
+    if (s.length() < p.length()) {
+      return list;
+    }
+    int[] pArr = new int[26];
+    for (char c : p.toCharArray()) {
+      pArr[c - 'a']++;
+    }
+    String pStr = Arrays.toString(pArr);
+    int start = 0;
+    int end = 0;
+    int n = s.length();
+    int[] sArr = new int[26];
+    while (end < (p.length() - 1)) {
+      sArr[s.charAt(end) - 'a']++;
+      end++;
+    }
+    while (end < n) {
+      sArr[s.charAt(end) - 'a']++;
+      end++;
+      if (Arrays.toString(sArr).equals(pStr)) {
+        list.add(start);
+      }
+      sArr[s.charAt(start++) - 'a']--;
+    }
+    return list;
+  }
+}

From dc72d0a7002c4c805bc7dd2b1939d2804808397a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 10 Jun 2020 22:19:16 -0500
Subject: [PATCH 0184/2175] Modified 2 solutions

---
 Easy/Paint Fence.java                     | 32 ++++---------
 Medium/Find Duplicate File in System.java | 57 ++++++++---------------
 2 files changed, 28 insertions(+), 61 deletions(-)

diff --git a/Easy/Paint Fence.java b/Easy/Paint Fence.java
index 6c8c1289..72ea89e6 100644
--- a/Easy/Paint Fence.java	
+++ b/Easy/Paint Fence.java	
@@ -1,26 +1,12 @@
 class Solution {
-    public int numWays(int n, int k) {
-        if (n == 0) {
-            return 0;
-        }
-        
-        if (n == 1) {
-            return k;
-        }
-        
-        if (n == 2) {
-            return k * k;
-        }
-        
-        int[] ways = new int[n + 1];
-        ways[0] = 0;
-        ways[1] = k;
-        ways[2] = k * k;
-        
-        for (int i = 3; i <= n; i++) {
-            ways[i] = ways[i - 1] * (k - 1) + ways[i - 2] * (k - 1);
-        }
-        
-        return ways[n];
+  public int numWays(int n, int k) {
+    int[] ways = new int[Math.max(n + 1, 3)];
+    ways[0] = 0;
+    ways[1] = k;
+    ways[2] = k * k;
+    for (int i = 3; i <= n; i++) {
+      ways[i] = (ways[i - 1] * (k - 1)) + (ways[i - 2] * (k - 1));
     }
+    return ways[n];
+  }
 }
diff --git a/Medium/Find Duplicate File in System.java b/Medium/Find Duplicate File in System.java
index 5ea4cd21..6570d540 100644
--- a/Medium/Find Duplicate File in System.java	
+++ b/Medium/Find Duplicate File in System.java	
@@ -1,41 +1,22 @@
 class Solution {
-    
-    public List<List<String>> findDuplicate(String[] paths) {
-
-        Map<String, ArrayList<String>> map = new HashMap<>();
-        List<List<String>> ans = new ArrayList<>();
-
-        for (String s : paths) {
-            String[] temp = s.split("\\s");
-
-            for (int i=1;i<temp.length;i++) {
-                String message = temp[i].substring(temp[i].indexOf("(")+1, temp[i].indexOf(")"));
-                String fileName = temp[i].substring(0, temp[i].indexOf("("));
-
-                if (map.containsKey(message)) {
-                    ArrayList<String> tempList = map.get(message);
-                    tempList.add(temp[0] + "/" + fileName);
-                    map.put(message, tempList);
-                }
-                else {
-                    ArrayList<String> tempList = new ArrayList<>();
-                    tempList.add(temp[0] + "/" + fileName);
-                    map.put(message, tempList);
-                }
-
-            }
-        }
-
-        for (Map.Entry<String,ArrayList<String>> entry : map.entrySet()) {
-
-            List<String> l = entry.getValue();
-
-            if (l.size() > 1) {
-                ans.add(l);
-            }
-            
-        }
-
-        return ans;
+  public List<List<String>> findDuplicate(String[] paths) {
+    Map<String, List<String>> map = new HashMap<>();
+    for (String path : paths) {
+      String[] strs = path.split("\\s+");
+      String filePath = strs[0];
+      for (int i = 1; i < strs.length; i++) {
+        int startIdx = strs[i].indexOf('(');
+        String fileName = strs[i].substring(0, startIdx);
+        String content = strs[i].substring(startIdx, strs[i].length());
+        map.computeIfAbsent(content, k -> new ArrayList<>()).add(filePath + "/" + fileName);
+      }
     }
+    List<List<String>> duplicateFiles = new ArrayList<>();
+    for (String key : map.keySet()) {
+      if (map.get(key).size() > 1) {
+        duplicateFiles.add(map.get(key));
+      } 
+    }
+    return duplicateFiles;
+  }
 }

From fb7069d5952f063942b03393825866eb74d60d52 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 11 Jun 2020 14:51:31 -0500
Subject: [PATCH 0185/2175] Added 1 solution & modified 1 solution

---
 ... Nodes After M Nodes of a Linked List.java | 40 +++++++++++++++++++
 Easy/Flipping an Image.java                   | 32 ++++++---------
 Easy/Leaf Similar Tree.java                   | 26 +++++++-----
 Easy/Leaf-Similar Trees.java                  | 34 ----------------
 4 files changed, 69 insertions(+), 63 deletions(-)
 create mode 100644 Easy/Delete N Nodes After M Nodes of a Linked List.java
 delete mode 100644 Easy/Leaf-Similar Trees.java

diff --git a/Easy/Delete N Nodes After M Nodes of a Linked List.java b/Easy/Delete N Nodes After M Nodes of a Linked List.java
new file mode 100644
index 00000000..4e3509bd
--- /dev/null
+++ b/Easy/Delete N Nodes After M Nodes of a Linked List.java	
@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode deleteNodes(ListNode head, int m, int n) {
+    ListNode curr = head;
+    ListNode prev = null;
+    boolean toDelete = false;
+    int deleteCount = 0;
+    int skipCount = 0;
+    while (curr != null) {
+      if (toDelete) {
+        prev.next = curr.next;
+        deleteCount++;
+        curr = prev.next;
+        if (deleteCount == n) {
+          deleteCount = 0;
+          toDelete = false;
+        }
+      }
+      else {
+        prev = curr;
+        curr = curr.next;
+        skipCount++;
+        if (skipCount == m) {
+          skipCount = 0;
+          toDelete = true;
+        }
+      }
+    }
+    return head;
+  }
+}
diff --git a/Easy/Flipping an Image.java b/Easy/Flipping an Image.java
index 540bff8e..8c4a0813 100644
--- a/Easy/Flipping an Image.java	
+++ b/Easy/Flipping an Image.java	
@@ -1,27 +1,19 @@
 class Solution {
   public int[][] flipAndInvertImage(int[][] A) {
     for (int[] arr : A) {
-      reverse(arr);
-      invert(arr);
+      int start = 0;
+      int end = arr.length - 1;
+      while (start < end) {
+        int temp = arr[start];
+        arr[start++] = arr[end];
+        arr[end--] = temp;
+      }
     }
-    return A;
-  }
-  
-  private void reverse(int[] arr) {
-    int start = 0;
-    int end = arr.length - 1;
-    while (start < end) {
-      int temp = arr[start];
-      arr[start] = arr[end];
-      arr[end] = temp;
-      start++;
-      end--;
-    }
-  }
-  
-  private void invert(int[] arr) {
-    for (int i = 0; i < arr.length; i++) {
-      arr[i] = arr[i] ^ 1;
+    for (int[] arr : A) {
+      for (int i = 0; i < arr.length; i++) {
+        arr[i] = arr[i] == 1 ? 0 : 1;
+      }
     }
+    return A;
   }
 }
diff --git a/Easy/Leaf Similar Tree.java b/Easy/Leaf Similar Tree.java
index 8124e3f7..5b79aa91 100644
--- a/Easy/Leaf Similar Tree.java	
+++ b/Easy/Leaf Similar Tree.java	
@@ -4,19 +4,27 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public boolean leafSimilar(TreeNode root1, TreeNode root2) {
-    List<Integer> leaf1 = new ArrayList<>();
-    List<Integer> leaf2 = new ArrayList<>();
-    populateLeaves(root1, leaf1);
-    populateLeaves(root2, leaf2);
-    return leaf1.equals(leaf2);
+    return getLeafSequence(root1).equals(getLeafSequence(root2));
   }
   
-  private void populateLeaves(TreeNode root, List<Integer> list) {
+  private String getLeafSequence(TreeNode root) {
+    List<Integer> list = new ArrayList<>();
+    helper(root, list);
+    return list.toString();
+  }
+  
+  private void helper(TreeNode root, List<Integer> list) {
     if (root == null) {
       return;
     }
@@ -24,8 +32,8 @@ private void populateLeaves(TreeNode root, List<Integer> list) {
       list.add(root.val);
     }
     else {
-      populateLeaves(root.left, list);
-      populateLeaves(root.right, list);
+      helper(root.left, list);
+      helper(root.right, list);
     }
   }
 }
diff --git a/Easy/Leaf-Similar Trees.java b/Easy/Leaf-Similar Trees.java
deleted file mode 100644
index 150afbbe..00000000
--- a/Easy/Leaf-Similar Trees.java	
+++ /dev/null
@@ -1,34 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    
-    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
-        StringBuilder sb1 = new StringBuilder();
-        StringBuilder sb2 = new StringBuilder();
-        
-        updateSB(root1, sb1);
-        updateSB(root2, sb2);
-        
-        return sb1.toString().equals(sb2.toString());
-    }
-    
-    private void updateSB(TreeNode root, StringBuilder sb) {
-        if (root == null) {
-            return;
-        }
-        
-        if (root.left == null && root.right == null) {
-            sb.append(String.valueOf(root.val)).append("-");
-        }
-        
-        updateSB(root.left, sb);
-        updateSB(root.right, sb);
-    }
-}

From f9d23dcf63c61d37ca339f155a15b00647769c04 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 12 Jun 2020 15:41:22 -0500
Subject: [PATCH 0186/2175] Modified 3 solutions

---
 Easy/Excel Sheet Column Title.java       | 21 +++---
 Easy/Non-decreasing Array.java           | 25 ++++---
 Medium/Insert Delete GetRandom O(1).java | 83 ++++++++++--------------
 3 files changed, 61 insertions(+), 68 deletions(-)

diff --git a/Easy/Excel Sheet Column Title.java b/Easy/Excel Sheet Column Title.java
index 4244c70d..fa1ab27d 100644
--- a/Easy/Excel Sheet Column Title.java	
+++ b/Easy/Excel Sheet Column Title.java	
@@ -1,12 +1,11 @@
-public class Solution {
-    public String convertToTitle(int n) {
-        StringBuilder sb = new StringBuilder("");
-        int mod = 0;
-        while (n > 0) {
-            mod = (n - 1) % 26;
-            sb.append(String.valueOf((char) (65 + mod)));
-            n = (n-mod)/26;
-        }
-        return sb.reverse().toString();
+class Solution {
+  public String convertToTitle(int n) {
+    StringBuilder sb = new StringBuilder();
+    while (n > 0) {
+      n--;
+      sb.append((char) ('A' + n % 26));
+      n /= 26;
     }
-}
\ No newline at end of file
+    return sb.reverse().toString();
+  }
+}
diff --git a/Easy/Non-decreasing Array.java b/Easy/Non-decreasing Array.java
index f291ee0a..e6ce5b01 100644
--- a/Easy/Non-decreasing Array.java	
+++ b/Easy/Non-decreasing Array.java	
@@ -1,13 +1,20 @@
 class Solution {
-    public boolean checkPossibility(int[] a) {
-        int c = 0;
-        for (int i = 1; i < a.length; i++) {
-            if (a[i] < a[i - 1]) {
-                if (c++ > 0) return false;
-                if (i - 2 < 0 || a[i - 2] <= a[i]) a[i - 1] = a[i];  
-                else a[i] = a[i - 1];  
-            }
+  public boolean checkPossibility(int[] nums) {
+    Integer probIdx = null;
+    for (int i = 0; i < nums.length - 1; i++) {
+      if (nums[i] > nums[i + 1]) {
+        if (probIdx != null) {
+          return false;
         }
-        return true;
+        probIdx = i;
+      }
     }
+    return (
+      probIdx == null || 
+      probIdx == 0 || 
+      probIdx == (nums.length - 2) || 
+      nums[probIdx - 1] <= nums[probIdx + 1] ||
+      nums[probIdx] <= nums[probIdx + 2]
+    );
+  }
 }
diff --git a/Medium/Insert Delete GetRandom O(1).java b/Medium/Insert Delete GetRandom O(1).java
index ec85d2a9..1149d866 100644
--- a/Medium/Insert Delete GetRandom O(1).java	
+++ b/Medium/Insert Delete GetRandom O(1).java	
@@ -1,55 +1,42 @@
 class RandomizedSet {
 
-    /** Initialize your data structure here. */
-    Map<Integer, Integer> map;
-    List<Integer> list;
-    int lastIndex;
-    public RandomizedSet() {
-        map = new HashMap<>();
-        list = new ArrayList<>();
-        lastIndex = 0;
+  /** Initialize your data structure here. */
+  Map<Integer, Integer> map;
+  List<Integer> list;
+  public RandomizedSet() {
+    map = new HashMap<>();
+    list = new ArrayList<>();
+  }
+
+  /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+  public boolean insert(int val) {
+    if (map.containsKey(val)) {
+      return false;
     }
-
-    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
-    public boolean insert(int val) {
-        if (map.containsKey(val)) {
-            return false;
-        }
-
-        list.add(val);
-        map.put(val, lastIndex);
-        lastIndex++;
-
-        return true;
-    }
-
-    /** Removes a value from the set. Returns true if the set contained the specified element. */
-    public boolean remove(int val) {
-        if (!map.containsKey(val)) {
-            return false;
-        }
-
-        map.put(list.get(lastIndex-1), map.get(val));
-        swap(map.get(val), lastIndex-1);
-        list.remove(lastIndex-1);
-        map.remove(val);
-        lastIndex--;
-
-        return true;
-    }
-
-    private void swap(int id1, int id2) {
-        int temp = list.get(id1);
-        list.set(id1, list.get(id2));
-        list.set(id2, temp);
-    }
-
-    /** Get a random element from the set. */
-    public int getRandom() {
-        Random rand = new Random();
-        int idx = rand.nextInt(((lastIndex-1) - 0) + 1) + 0;
-        return list.get(idx);
+    list.add(val);
+    map.put(val, list.size() - 1);
+    return true;
+  }
+
+  /** Removes a value from the set. Returns true if the set contained the specified element. */
+  public boolean remove(int val) {
+    if (!map.containsKey(val)) {
+      return false;
     }
+    int idx = map.get(val);
+    int lastIdx = list.size() - 1;
+    list.set(idx, list.get(lastIdx));
+    map.put(list.get(lastIdx), idx);
+    map.remove(val);
+    list.remove(lastIdx);
+    return true;
+  }
+
+  /** Get a random element from the set. */
+  public int getRandom() {
+    int idx = new Random().nextInt(list.size());
+    return list.get(idx);
+  }
 }
 
 /**

From 106929c42f5fc3f7729f5cf60ea5e74fb4012e8a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 13 Jun 2020 10:37:00 -0500
Subject: [PATCH 0187/2175] Added Implement Magic Dictionary.java

---
 Medium/Implement Magic Dictionary.java | 51 ++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 Medium/Implement Magic Dictionary.java

diff --git a/Medium/Implement Magic Dictionary.java b/Medium/Implement Magic Dictionary.java
new file mode 100644
index 00000000..d3a1547d
--- /dev/null
+++ b/Medium/Implement Magic Dictionary.java	
@@ -0,0 +1,51 @@
+class MagicDictionary {
+
+  /** Initialize your data structure here. */
+  Set<String> words;
+  Map<String, Integer> count;
+  public MagicDictionary() {
+    words = new HashSet<>();
+    count = new HashMap<>();
+  }
+  
+  private List<String> generalizedNeighbour(String word) {
+    List<String> list = new ArrayList<>();
+    char[] chars = word.toCharArray();
+    for (int i = 0; i < chars.length; i++) {
+      char letter = chars[i];
+      chars[i] = '*';
+      String magic = new String(chars);
+      list.add(magic);
+      chars[i] = letter;
+    }
+    return list;
+  }
+
+  /** Build a dictionary through a list of words */
+  public void buildDict(String[] dict) {
+    for (String word : dict) {
+      words.add(word);
+      for (String neighbour : generalizedNeighbour(word)) {
+        count.put(neighbour, count.getOrDefault(neighbour, 0) + 1);
+      }
+    }
+  }
+
+  /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
+  public boolean search(String word) {
+    for (String neighbour : generalizedNeighbour(word)) {
+      int c = count.getOrDefault(neighbour, 0);
+      if (c > 1 || c == 1 && !words.contains(word)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
+ * Your MagicDictionary object will be instantiated and called as such:
+ * MagicDictionary obj = new MagicDictionary();
+ * obj.buildDict(dict);
+ * boolean param_2 = obj.search(word);
+ */

From 607de4a5aef655e5f41b31d2264151908b26c34a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 13 Jun 2020 16:21:27 -0500
Subject: [PATCH 0188/2175] Added 3 solutions & modified 1 solution

---
 ...ces With a Special Discount in a Shop.java | 14 ++++
 Easy/Find Mode in Binary Search Tree.java     | 82 ++++++++++---------
 Medium/Camelcase Matching.java                | 34 ++++++++
 Medium/Large Divisble Subset.java             | 38 +++++++++
 4 files changed, 131 insertions(+), 37 deletions(-)
 create mode 100644 Easy/Final Prices With a Special Discount in a Shop.java
 create mode 100644 Medium/Camelcase Matching.java
 create mode 100644 Medium/Large Divisble Subset.java

diff --git a/Easy/Final Prices With a Special Discount in a Shop.java b/Easy/Final Prices With a Special Discount in a Shop.java
new file mode 100644
index 00000000..4c78e72f
--- /dev/null
+++ b/Easy/Final Prices With a Special Discount in a Shop.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int[] finalPrices(int[] prices) {
+    Stack<Integer> stack = new Stack<>();
+    int[] finalPrice = new int[prices.length];
+    for (int i = prices.length - 1; i >= 0; i--) {
+      while (!stack.isEmpty() && prices[stack.peek()] > prices[i]) {
+        stack.pop();
+      }
+      finalPrice[i] = prices[i] - (stack.isEmpty() ? 0 : prices[stack.peek()]);
+      stack.push(i);
+    }
+    return finalPrice;
+  }
+}
diff --git a/Easy/Find Mode in Binary Search Tree.java b/Easy/Find Mode in Binary Search Tree.java
index b88f9d7e..a803103b 100644
--- a/Easy/Find Mode in Binary Search Tree.java	
+++ b/Easy/Find Mode in Binary Search Tree.java	
@@ -4,46 +4,54 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int[] findMode(TreeNode root) {
-        Map<Integer, Integer> map = new HashMap<>();
-        inorderTraversal(root, map);
-        
-        int maxVal = 0;
-        int count = 0;
-        
-        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            if (entry.getValue() > maxVal) {
-                maxVal = entry.getValue();
-                count = 1;
-            }    
-            else if (entry.getValue() == maxVal) {
-                count++;
-            }    
-        }
-        
-        int[] ans = new int[count];
-        int i = 0;
-        
-        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            if (entry.getValue() == maxVal) {
-                ans[i++] = entry.getKey();
-            }
-        }
-        
-        return ans;
-        
+  Integer prev = null;
+  int count = 1;
+  int max = 0;
+  public int[] findMode(TreeNode root) {
+    if (root == null) {
+      return new int[0];
     }
-    
-    public void inorderTraversal(TreeNode root, Map<Integer, Integer> map) {
-        
-        if (root == null) return;
-        
-        inorderTraversal(root.left, map);
-        map.put(root.val, map.getOrDefault(root.val, 0) + 1);
-        inorderTraversal(root.right, map);
+    List<Integer> list = new ArrayList<>();
+    traverse(root, list);
+    int[] ans = new int[list.size()];
+    for (int i = 0; i < list.size(); i++) {
+      ans[i] = list.get(i);
     }
+    return ans;
+  }
+  
+  private void traverse(TreeNode root, List<Integer> list) {
+    if (root == null) {
+      return;
+    }
+    traverse(root.left, list);
+    if (prev != null) {
+      if (root.val == prev) {
+        count++;
+      }
+      else {
+        count = 1;
+      }
+    }
+    if (count > max) {
+      max = count;
+      list.clear();
+      list.add(root.val);
+    }
+    else if (count == max) {
+      list.add(root.val);
+    }
+    prev = root.val;
+    traverse(root.right, list);
+  }
 }
diff --git a/Medium/Camelcase Matching.java b/Medium/Camelcase Matching.java
new file mode 100644
index 00000000..034db73d
--- /dev/null
+++ b/Medium/Camelcase Matching.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public List<Boolean> camelMatch(String[] queries, String pattern) {
+    List<Boolean> list = new ArrayList<>();
+    for (String query : queries) {
+      list.add(isMatch(query, pattern));
+    }
+    return list;
+  }
+  
+  private boolean isMatch(String query, String pattern) {
+    int idxQuery = 0;
+    int idxPattern = 0;
+    int lenQuery = query.length();
+    int lenPattern = pattern.length();
+    while (idxQuery < lenQuery && idxPattern < lenPattern) {
+      char queryC = query.charAt(idxQuery);
+      char patternC = pattern.charAt(idxPattern);
+      if (queryC == patternC) {
+        idxQuery++;
+        idxPattern++;
+      }
+      else if (Character.isUpperCase(queryC)) {
+        return false;
+      }
+      else {
+        idxQuery++;
+      }
+    }
+    while (idxQuery < lenQuery && Character.isLowerCase(query.charAt(idxQuery))) {
+      idxQuery++;
+    }
+    return idxPattern == lenPattern && idxQuery == lenQuery;
+  }
+}
diff --git a/Medium/Large Divisble Subset.java b/Medium/Large Divisble Subset.java
new file mode 100644
index 00000000..a65f1d15
--- /dev/null
+++ b/Medium/Large Divisble Subset.java	
@@ -0,0 +1,38 @@
+class Solution {
+  public List<Integer> largestDivisibleSubset(int[] nums) {
+    int n = nums.length;
+    if (n == 0) {
+      return new ArrayList<>();
+    }
+    Map<Integer, List<Integer>> map = new HashMap<>();
+    Arrays.sort(nums);
+    List<Integer> maxSubset = new ArrayList<>();
+    for (int i = 0; i < n; i++) {
+      List<Integer> subset = helper(i, map, nums);
+      if (subset.size() > maxSubset.size()) {
+        maxSubset = subset;
+      }
+    }
+    return maxSubset;
+  }
+  
+  private List<Integer> helper(int i, Map<Integer, List<Integer>> map, int[] nums) {
+    if (map.containsKey(i)) {
+      return map.get(i);
+    }
+    List<Integer> maxSubset = new ArrayList<>();
+    for (int k = 0; k < i; k++) {
+      if (nums[i] % nums[k] == 0) {
+        List<Integer> subset = helper(k, map, nums);
+        if (maxSubset.size() < subset.size()) {
+          maxSubset = subset;
+        }
+      }
+    }
+    List<Integer> newEntry = new ArrayList<>();
+    newEntry.addAll(maxSubset);
+    newEntry.add(nums[i]);
+    map.put(i, newEntry);
+    return newEntry;
+  }
+}

From 1d6ea955a868edab52731411da5cf0fc1202086f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 14 Jun 2020 13:36:02 -0500
Subject: [PATCH 0189/2175] Added 2 solutions & modified 1 solution

---
 Easy/Running Sum of 1d Array.java             |  11 ++
 ...r of Unique Integers after K Removals.java |  28 +++++
 Medium/Replace Words.java                     | 109 ++++++++----------
 3 files changed, 90 insertions(+), 58 deletions(-)
 create mode 100644 Easy/Running Sum of 1d Array.java
 create mode 100644 Medium/Least Number of Unique Integers after K Removals.java

diff --git a/Easy/Running Sum of 1d Array.java b/Easy/Running Sum of 1d Array.java
new file mode 100644
index 00000000..75f635ca
--- /dev/null
+++ b/Easy/Running Sum of 1d Array.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int[] runningSum(int[] nums) {
+    int[] ans = new int[nums.length];
+    int sum = 0;
+    for (int i = 0; i < nums.length; i++) {
+      sum += nums[i];
+      ans[i] = sum;
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Least Number of Unique Integers after K Removals.java b/Medium/Least Number of Unique Integers after K Removals.java
new file mode 100644
index 00000000..30b56fac
--- /dev/null
+++ b/Medium/Least Number of Unique Integers after K Removals.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public int findLeastNumOfUniqueInts(int[] arr, int k) {
+    Map<Integer, Integer> map = new HashMap<>();
+    List<Integer> list = new ArrayList<>();
+    for (int num : arr) {
+      if (!map.containsKey(num)) {
+        list.add(num);
+      }
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    Collections.sort(list, new Comparator<Integer>(){
+      public int compare(Integer o1, Integer o2) {
+        return map.get(o1) - map.get(o2);
+      }
+    });
+    for (Integer num : list) {
+      int count = map.get(num);
+      k -= count;
+      if (k >= 0) {
+        map.remove(num);
+      }
+      else {
+       break; 
+      }
+    }
+    return map.size();
+  }
+}
diff --git a/Medium/Replace Words.java b/Medium/Replace Words.java
index 3e8c6e14..0fd7e0e6 100644
--- a/Medium/Replace Words.java	
+++ b/Medium/Replace Words.java	
@@ -1,63 +1,56 @@
 class Solution {
-    
-    public String replaceWords(List<String> dict, String sentence) {
-
-        Map<String, Integer> map = new HashMap<>();
-
-        for (String s: dict) {
-            map.put(s, s.length());
-        }
-
-        Map<String, Integer> sortedMap = sortByValue(map);
-
-        String[] arr = sentence.split("\\s");
-        String[] ans = new String[arr.length];
-        int j = 0;
-
-        for (String s : arr) {
-            boolean gotIt = false;
-            for (Map.Entry<String,Integer> entry : sortedMap.entrySet()) {
-                if (s.startsWith(entry.getKey())) {
-                    ans[j] = entry.getKey();
-                    gotIt = true;
-                    break;
-                }
-            }
-
-            if (!gotIt) {
-                ans[j] = s;
-            }
-
-            j++;
-        }
-
-        StringBuilder ansString = new StringBuilder("");
-
-        for (String s : ans) {
-            ansString.append(s + " ");
-        }
-
-        return ansString.toString().trim();
+  public String replaceWords(List<String> dict, String sentence) {
+    Node root = new Node('-');
+    for (String word : dict) {
+      addWord(word, 0, root);
     }
-
-    private Map<String, Integer> sortByValue(Map<String, Integer> unsortMap) {
-
-        List<Map.Entry<String, Integer>> list =
-                new LinkedList<Map.Entry<String, Integer>>(unsortMap.entrySet());
-
-        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
-            public int compare(Map.Entry<String, Integer> o1,
-                               Map.Entry<String, Integer> o2) {
-                return (o1.getValue()).compareTo(o2.getValue());
-            }
-        });
-
-        Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
-        for (Map.Entry<String, Integer> entry : list) {
-            sortedMap.put(entry.getKey(), entry.getValue());
-        }
-
-        return sortedMap;
+    String[] words = sentence.split("\\s+");
+    for (int i = 0; i < words.length; i++) {
+      String prefix = getPrefix(words[i], root);
+      if (prefix != null) {
+        words[i] = prefix;
+      }
+    }
+    return String.join(" ", words);
+  }
+  
+  private String getPrefix(String word, Node root) {
+    for (int i = 0; i < word.length(); i++) {
+      if (!root.children.containsKey(word.charAt(i))) {
+        return null;
+      }
+      root = root.children.get(word.charAt(i));
+      if (root.word != null) {
+        return root.word;
+      }
     }
+    return null;
+  }
+  
+  private void addWord(String word, int idx, Node root) {
+    if (idx == word.length()) {
+      return;
+    }
+    if (!root.children.containsKey(word.charAt(idx))) {
+      root.children.put(word.charAt(idx), new Node(word.charAt(idx)));
+    }
+    root = root.children.get(word.charAt(idx));
+    if (idx == word.length() - 1) {
+      root.word = word;
+    }
+    addWord(word, idx + 1, root);
+  }
+}
+
 
+class Node {
+  char c;
+  Map<Character, Node> children;
+  String word;
+  
+  public Node(char c) {
+    this.c = c;
+    children = new HashMap<>();
+    word = null;
+  }
 }

From c896e5009d294d11de1a59de1165cf748f9f25d5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 14 Jun 2020 18:16:40 -0500
Subject: [PATCH 0190/2175] Added 1 solution & modified 1 solution

---
 Hard/Prefix and Suffix Search.java | 119 ++++++++++++-----------------
 Medium/Subrectangle Queries.java   |  32 ++++++++
 2 files changed, 79 insertions(+), 72 deletions(-)
 create mode 100644 Medium/Subrectangle Queries.java

diff --git a/Hard/Prefix and Suffix Search.java b/Hard/Prefix and Suffix Search.java
index 81822d71..4a791c66 100644
--- a/Hard/Prefix and Suffix Search.java	
+++ b/Hard/Prefix and Suffix Search.java	
@@ -1,86 +1,61 @@
 class WordFilter {
 
-    Map<String, Integer> wordWeight;
-    Node root;
-    public WordFilter(String[] words) {
-        wordWeight = new HashMap<>();
-        root = new Node("");
-        for (int i=0; i<words.length; i++) {
-            wordWeight.put(words[i], i);
-            insertWord(words[i]);
-        }
+  Node root;
+  Map<String, Integer> weightMap;
+  public WordFilter(String[] words) {
+    root = new Node('-');
+    weightMap = new HashMap<>();
+    for (int i = 0; i < words.length; i++) {
+      root.words.add(words[i]);
+      addWord(words[i], 0, root);
+      weightMap.put(words[i], i);
     }
-
-    private void insertWord(String word) {
-        Node curr = root;
-        for (int i=0; i<word.length(); i++) {
-            if (!curr.childrens.containsKey(word.charAt(i))) {
-                Node temp = new Node(word.substring(0, i+1));
-                curr.childrens.put(word.charAt(i), temp);
-            }
-
-            curr = curr.childrens.get(word.charAt(i));
-
-            if (i == (word.length() - 1)) {
-                curr.isWord = true;
-            }
-        }
+  }
+  
+  private void addWord(String word, int idx, Node curr) {
+    if (idx == word.length()) {
+      return;
     }
-
-    public int f(String prefix, String suffix) {
-        List<String> words = getWords(prefix);
-        int idx = -1;
-        int maxWeight = Integer.MIN_VALUE;
-
-        for (String word : words) {
-            if (word.endsWith(suffix)) {
-                if (wordWeight.get(word) > maxWeight) {
-                    maxWeight = wordWeight.get(word);
-                    idx = wordWeight.get(word);
-                }
-            }
-        }
-
-        return idx;
+    char c = word.charAt(idx);
+    if (!curr.children.containsKey(c)) {
+      curr.children.put(c, new Node(c));
     }
+    curr = curr.children.get(c);
+    curr.words.add(word);
+    addWord(word, idx + 1, curr);
+  }
 
-    private List<String> getWords(String prefix) {
-        List<String> words = new ArrayList<>();
-        Node curr = root;
-        for (int i=0; i<prefix.length(); i++) {
-            if (curr.childrens.containsKey(prefix.charAt(i))) {
-                curr = curr.childrens.get(prefix.charAt(i));
-            }
-            else {
-                return words;
-            }
+  public int f(String prefix, String suffix) {
+    Node curr = root;
+    if (prefix.length() != 0) {
+      for (char c : prefix.toCharArray()) {
+        if (!curr.children.containsKey(c)) {
+          return -1;
         }
-
-        findAllChildWords(words, curr);
-
-        return words;
+        curr = curr.children.get(c);
+      }
     }
-
-    private void findAllChildWords(List<String> words, Node curr) {
-        if (curr.isWord) {
-            words.add(curr.prefix);
-        }
-
-        for (char c : curr.childrens.keySet()) {
-            findAllChildWords(words, curr.childrens.get(c));
-        }
+    int ans = -1;
+    for (String word : curr.words) {
+      if (suffix.length() == 0 || word.endsWith(suffix)) {
+        ans = Math.max(ans, weightMap.get(word));
+      }
     }
+    return ans;
+  }
+}
 
-    class Node {
-        String prefix;
-        Map<Character, Node> childrens;
-        boolean isWord = false;
 
-        public Node(String prefix) {
-            this.prefix = prefix;
-            childrens = new HashMap<>();
-        }
-    }
+class Node {
+  char c;
+  Map<Character, Node> children;
+  Set<String> words;
+  
+  public Node(char c) {
+    this.c = c;
+    children = new HashMap<>();
+    words = new HashSet<>();
+  } 
 }
 
 /**
diff --git a/Medium/Subrectangle Queries.java b/Medium/Subrectangle Queries.java
new file mode 100644
index 00000000..2fb42221
--- /dev/null
+++ b/Medium/Subrectangle Queries.java	
@@ -0,0 +1,32 @@
+class SubrectangleQueries {
+  List<int[]> modifications;
+  int[][] rectangle;
+  public SubrectangleQueries(int[][] rectangle) {
+    this.rectangle = rectangle;
+    modifications = new ArrayList<>();
+  }
+
+  public void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) {
+    modifications.add(new int[]{row1, col1, row2, col2, newValue});
+  }
+
+  public int getValue(int row, int col) {
+    for (int i = modifications.size() - 1; i >= 0; i--) {
+      if (inRange(row, col, modifications.get(i))) {
+        return modifications.get(i)[4];
+      }
+    }
+    return rectangle[row][col];
+  }
+  
+  private boolean inRange(int row, int col, int[] modification) {
+    return row >= modification[0] && row <= modification[2] && col >= modification[1] && col <= modification[3];
+  }
+}
+
+/**
+ * Your SubrectangleQueries object will be instantiated and called as such:
+ * SubrectangleQueries obj = new SubrectangleQueries(rectangle);
+ * obj.updateSubrectangle(row1,col1,row2,col2,newValue);
+ * int param_2 = obj.getValue(row,col);
+ */

From 837609e308d7636f31ce73a24a049e72dc1853b7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 15 Jun 2020 18:22:46 -0500
Subject: [PATCH 0191/2175] Added 1 solution & modified 1 solution

---
 Easy/Minimum Time Visiting All Points.java | 13 ++++++++
 Easy/Search in a Binary Search Tree.java   | 35 ++++++++++++----------
 2 files changed, 33 insertions(+), 15 deletions(-)
 create mode 100644 Easy/Minimum Time Visiting All Points.java

diff --git a/Easy/Minimum Time Visiting All Points.java b/Easy/Minimum Time Visiting All Points.java
new file mode 100644
index 00000000..774ac97c
--- /dev/null
+++ b/Easy/Minimum Time Visiting All Points.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int minTimeToVisitAllPoints(int[][] points) {
+    int time = 0;
+    for (int i = 1; i < points.length; i++) {
+      int[] prevPoint = points[i - 1];
+      int[] currPoint = points[i];
+      time += Math.max(
+        Math.abs(prevPoint[0] - currPoint[0]), Math.abs(prevPoint[1] - currPoint[1])
+      );
+    }
+    return time;
+  }
+}
diff --git a/Easy/Search in a Binary Search Tree.java b/Easy/Search in a Binary Search Tree.java
index 8df18f2e..caed08fe 100644
--- a/Easy/Search in a Binary Search Tree.java	
+++ b/Easy/Search in a Binary Search Tree.java	
@@ -4,23 +4,28 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode searchBST(TreeNode root, int val) {
-        if (root == null) {
-            return null;
-        }
-        
-        if(root.val == val) {
-            return root;
-        }
-        else if (root.val < val) {
-            return searchBST(root.right, val);
-        }
-        else {
-            return searchBST(root.left, val);
-        }
+  public TreeNode searchBST(TreeNode root, int val) {
+    if (root == null) {
+      return null;
     }
+    if (root.val == val) {
+      return root;
+    }
+    else if (root.val > val) {
+      return searchBST(root.left, val);
+    }
+    else {
+      return searchBST(root.right, val);
+    }
+  }
 }

From 6e66e6626a7f4ba2611c4f8c97226dfef38eed2d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 15 Jun 2020 20:31:13 -0500
Subject: [PATCH 0192/2175] Solved 2 solutions

---
 Easy/DI String Match.java      | 13 +++++++++++++
 Easy/Self Dividing Number.java | 23 +++++++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 Easy/DI String Match.java
 create mode 100644 Easy/Self Dividing Number.java

diff --git a/Easy/DI String Match.java b/Easy/DI String Match.java
new file mode 100644
index 00000000..f33d420d
--- /dev/null
+++ b/Easy/DI String Match.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int[] diStringMatch(String S) {
+    int n = S.length();
+    int low = 0;
+    int high = n;
+    int[] ans = new int[n + 1];
+    for (int i = 0; i < n; i++) {
+      ans[i] = S.charAt(i) == 'I' ? low++ : high--;
+    }
+    ans[n] = low;
+    return ans;
+  }
+}
diff --git a/Easy/Self Dividing Number.java b/Easy/Self Dividing Number.java
new file mode 100644
index 00000000..dd0c952a
--- /dev/null
+++ b/Easy/Self Dividing Number.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public List<Integer> selfDividingNumbers(int left, int right) {
+    List<Integer> ans = new ArrayList<>();
+    for (int i = left; i <= right; i++) {
+      if (isSelfDivisible(i)) {
+        ans.add(i);
+      }
+    }
+    return ans;
+  }
+  
+  private boolean isSelfDivisible(int num) {
+    int copy = num;
+    while (copy > 0) {
+      int rem = copy % 10;
+      copy /= 10;
+      if (rem == 0 || num % rem != 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

From 70c17a7b5d79ee3ccfb28624cbbf16de6c7e7344 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 16 Jun 2020 20:08:27 -0500
Subject: [PATCH 0193/2175] Modified Validate IP Address.java

---
 Medium/Validate IP Address.java | 149 ++++++++++++++++++--------------
 1 file changed, 86 insertions(+), 63 deletions(-)

diff --git a/Medium/Validate IP Address.java b/Medium/Validate IP Address.java
index 7435cbc7..b63c5a59 100644
--- a/Medium/Validate IP Address.java	
+++ b/Medium/Validate IP Address.java	
@@ -1,74 +1,97 @@
 class Solution {
-    Set<Character> hexCharSet = new HashSet<>(Arrays.asList('a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F'));
-    
-    public String validIPAddress(String IP) {
-        if (IP.indexOf('.') != -1) {
-            return isValidIPv4(IP) ? "IPv4" : "Neither";
-        }
-        else if (IP.indexOf(':') != -1) {
-            return isValidIPv6(IP) ? "IPv6" : "Neither";
-        }
-        
-        return "Neither";
+  public String validIPAddress(String IP) {
+    if (IP.indexOf(':') != -1) {
+      return validateIPv6(IP);
+    }
+    else if (IP.indexOf('.') != -1) {
+      return validateIPv4(IP);
     }
-    
-    private boolean isValidIPv4(String ip) {
-        if (ip.startsWith(".") || ip.endsWith(".")) {
-            return false;
+    else {
+      return "Neither";
+    }
+  }
+  
+  private String validateIPv6(String ip) {
+    int count = 0;
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < ip.length(); i++) {
+      if (ip.charAt(i) == ':') {
+        if (!isValidIPv6(sb.toString())) {
+          return "Neither";
         }
-        String[] components = ip.split("\\.");
-        if (components.length != 4) {
-            return false;
+        sb = new StringBuilder();
+        count++;
+      }
+      else {
+        sb.append(ip.charAt(i));
+      }
+      if (i == ip.length() - 1) {
+        if (!isValidIPv6(sb.toString())) {
+          return "Neither";
         }
-        
-        for (String component : components) {
-            try {
-                int value = Integer.parseInt(component);
-                if (value < 0 || value > 255) {
-                    return false;
-                }
-                
-                if (value > 0 && component.startsWith("0")) {
-                    return false;
-                }
-                
-                if (value == 0 && component.length() > 1) {
-                    return false;
-                }
-            } catch(Exception e) {
-                return false;
-            }
+      }
+    }
+    return count == 7 ? "IPv6" : "Neither";
+  }
+  
+  private boolean isValidIPv6(String s) {
+    String lower = "abcdef";
+    String upper = "ABCDEF";
+    if (s.length() == 0 || s.length() > 4) {
+      return false;
+    }
+    for (char c : s.toCharArray()) {
+      if (!Character.isDigit(c)) {
+        if (lower.indexOf(c) == -1 && upper.indexOf(c) == -1) {
+          return false;
         }
-        
-        return true;
+      }
     }
-    
-    private boolean isValidIPv6(String ip) {
-        if (ip.startsWith(":") || ip.endsWith(":")) {
-            return false;
+    return true;
+  }
+  
+  private String validateIPv4(String ip) {
+    StringBuilder sb = new StringBuilder();
+    int count = 0;
+    for (int i = 0; i < ip.length(); i++) {
+      if (ip.charAt(i) == '.') {
+        if (!isValidIPv4(sb.toString())) {
+          return "Neither";
         }
-        
-        String[] components = ip.split(":");
-        if (components.length != 8) {
-            return false;
+        sb = new StringBuilder();
+        count++;
+      }
+      else {
+        if (!Character.isDigit(ip.charAt(i))) {
+          return "Neither";
         }
-        
-        for (String component : components) {
-            if (component.length() > 4 || component.length() == 0) {
-                return false;
-            }
-            for (char c : component.toCharArray()) {
-                if (Character.isLetter(c) && hexCharSet.contains(c)) {
-                    continue;
-                }
-                else if (Character.isDigit(c)) {
-                    continue;
-                }
-                else {
-                    return false;
-                }
-            }
+        sb.append(ip.charAt(i));
+      }
+      if (i == ip.length() - 1) {
+        if (!isValidIPv4(sb.toString())) {
+          return "Neither";
         }
-        return true;
+      }
+    }
+    return count == 3 ? "IPv4" : "Neither";
+  }
+  
+  private boolean isValidIPv4(String s) {
+    if (s.length() == 0) {
+      return false;
+    }
+    try {
+      int val = Integer.parseInt(s);
+      if (val < 0 || val > 255) {
+        return false;
+      }
+      if ((s.startsWith("0") && val != 0) || (val == 0 && s.length() > 1)) {
+        return false;
+      }
+    }
+    catch (NumberFormatException e) {
+      return false;
     }
+    return true;
+  }
 }

From 281133cdc07940e7e110ed55da975a1108cc3c42 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 17 Jun 2020 16:40:57 -0500
Subject: [PATCH 0194/2175] Added Surrounded Regions.java

---
 Medium/Surrounded Regions.java | 50 ++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 Medium/Surrounded Regions.java

diff --git a/Medium/Surrounded Regions.java b/Medium/Surrounded Regions.java
new file mode 100644
index 00000000..1c161f6c
--- /dev/null
+++ b/Medium/Surrounded Regions.java	
@@ -0,0 +1,50 @@
+class Solution {
+  public void solve(char[][] board) {
+    if (board == null || board.length == 0) {
+      return;
+    }
+    int rows = board.length;
+    int cols = board[0].length;
+    List<List<Integer>> borders = new ArrayList<>();
+    for (int r = 0; r < rows; r++) {
+      borders.add(Arrays.asList(r, 0));
+      borders.add(Arrays.asList(r, cols - 1));
+    }
+    for (int c = 0; c < cols; c++) {
+      borders.add(Arrays.asList(0, c));
+      borders.add(Arrays.asList(rows - 1, c));
+    }
+    for (List<Integer> border : borders) {
+      dfs(board, border.get(0), border.get(1), rows, cols);
+    }
+    for (int r = 0; r < rows; r++) {
+      for (int c = 0; c < cols; c++) {
+        if (board[r][c] == 'O') {
+          board[r][c] = 'X';
+        }
+        if (board[r][c] == 'E') {
+          board[r][c] = 'O';
+        }
+      }
+    }
+  }
+  
+  private void dfs(char[][] board, int row, int col, int rows, int cols) {
+    if (board[row][col] != 'O') {
+      return;
+    }
+    board[row][col] = 'E';
+    if (col < cols - 1) {
+      dfs(board, row, col + 1, rows, cols);
+    }
+    if (row < rows - 1) {
+      dfs(board, row + 1, col, rows, cols);
+    }
+    if (col > 0) {
+      dfs(board, row, col - 1, rows, cols);
+    }
+    if (row > 0) {
+      dfs(board, row - 1, col, rows, cols);
+    }
+  }
+}

From b0b781377c46afb9bb998656c98d95cade6b249f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 17 Jun 2020 20:00:54 -0500
Subject: [PATCH 0195/2175] Modified 2 solutions

---
 Medium/Sum Root to Leaf Numbers.java | 39 ++++++++++-------
 Medium/Walls and Gates.java          | 62 ++++++++++++----------------
 2 files changed, 52 insertions(+), 49 deletions(-)

diff --git a/Medium/Sum Root to Leaf Numbers.java b/Medium/Sum Root to Leaf Numbers.java
index 3940ea06..c24f21aa 100644
--- a/Medium/Sum Root to Leaf Numbers.java	
+++ b/Medium/Sum Root to Leaf Numbers.java	
@@ -4,22 +4,33 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
-class Solution { 
-    public int sumNumbers(TreeNode root) {    
-        return sum(root, 0);
+class Solution {
+  public int sumNumbers(TreeNode root) {
+    int[] sum = {0};
+    helper(root, sum, 0);
+    return sum[0];
+  }
+  
+  private void helper(TreeNode node, int[] sum, int currVal) {
+    if (node == null) {
+      return;
     }
-    
-    private int sum(TreeNode root, int sum) {
-        if (root == null) {
-            return 0;
-        }
-        if (root.left == null && root.right == null) {
-            return sum*10 + root.val;
-        }
-        
-        return sum(root.left, sum*10 + root.val) + sum(root.right, sum*10 + root.val);
+    currVal = currVal * 10 + node.val;
+    if (node.left == null && node.right == null) {
+      sum[0] += currVal;
     }
+    else {
+      helper(node.left, sum, currVal);
+      helper(node.right, sum, currVal);
+    }
+  }
 }
diff --git a/Medium/Walls and Gates.java b/Medium/Walls and Gates.java
index e030ae7a..02b45cc4 100644
--- a/Medium/Walls and Gates.java	
+++ b/Medium/Walls and Gates.java	
@@ -1,40 +1,32 @@
 class Solution {
-    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-    public void wallsAndGates(int[][] rooms) {
-        if (rooms.length == 0 || rooms[0].length == 0) {
-            return;
-        }
-        
-        Queue<Integer> queue = new LinkedList<>();
-        int numRows = rooms.length;
-        int numCols = rooms[0].length;
-        
-        for (int i = 0; i < numRows; i++) {
-            for (int j = 0; j < numCols; j++) {
-                if (rooms[i][j] == 0) {
-                    int key = i * numCols + j;
-                    queue.add(key);
-                }
-            }
+  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public void wallsAndGates(int[][] rooms) {
+    if (rooms.length == 0 || rooms[0].length == 0) {
+      return;
+    }
+    final int INF = Integer.MAX_VALUE;
+    Queue<int[]> queue = new LinkedList<>();
+    int rows = rooms.length;
+    int cols = rooms[0].length;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (rooms[i][j] == 0) {
+          queue.add(new int[]{i, j});
         }
-        
-        while (!queue.isEmpty()) {
-            int removed = queue.remove();
-            int x = removed / numCols;
-            int y = removed % numCols;
-            
-            for (int[] dir : dirs) {
-                int newX = x + dir[0];
-                int newY = y + dir[1];
-                
-                if (newX < 0 || newX >= numRows || newY < 0 || newY >= numCols || rooms[newX][newY] != 2147483647) {
-                    continue;    
-                }
-                
-                rooms[newX][newY] = rooms[x][y] + 1;
-                int newKey = newX * numCols + newY;
-                queue.add(newKey);
-            }
+      }
+    }
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int x = removed[0];
+      int y = removed[1];
+      for (int[] dir : dirs) {
+        int newX = x + dir[0];
+        int newY = y + dir[1];
+        if (newX >= 0 && newY >= 0 && newX < rows && newY < cols && rooms[newX][newY] == INF) {
+          rooms[newX][newY] = rooms[x][y] + 1;
+          queue.add(new int[]{newX, newY});
         }
+      }
     }
+  }
 }

From 229f4173bcbf5d607876beb8b130a011d2cd2432 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 18 Jun 2020 22:45:42 -0500
Subject: [PATCH 0196/2175] Modified H-Index.java

---
 Medium/H-Index.java | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/Medium/H-Index.java b/Medium/H-Index.java
index e872d3be..c16895b3 100644
--- a/Medium/H-Index.java
+++ b/Medium/H-Index.java
@@ -1,16 +1,12 @@
 class Solution {
-    public int hIndex(int[] citations) {
-        Arrays.sort(citations);
-        int end = citations.length;
-        int ind = 0;
-        
-        for (int i=0; i<end; i++) {
-            if (citations[i] >= end - i) {
-                ind = end - i;
-                break;
-            }
-        }
-        
-        return ind;
+  public int hIndex(int[] citations) {
+    int n = citations.length;
+    Arrays.sort(citations);
+    for (int i = n - 1; i >= 0; i--) {
+      if (n - i > citations[i]) {
+        return n - i - 1;
+      }
     }
+    return n;
+  }
 }

From f6fbc3b782e8c1a5f3e90364e609ad6618315992 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 20 Jun 2020 15:31:03 -0500
Subject: [PATCH 0197/2175] Added 2 solutions

---
 Easy/Lucky Numbers in a Matrix.java           | 24 ++++++++++
 ...Clone Binary Tree With Random Pointer.java | 47 +++++++++++++++++++
 2 files changed, 71 insertions(+)
 create mode 100644 Easy/Lucky Numbers in a Matrix.java
 create mode 100644 Medium/Clone Binary Tree With Random Pointer.java

diff --git a/Easy/Lucky Numbers in a Matrix.java b/Easy/Lucky Numbers in a Matrix.java
new file mode 100644
index 00000000..01b0bed3
--- /dev/null
+++ b/Easy/Lucky Numbers in a Matrix.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public List<Integer> luckyNumbers (int[][] matrix) {
+    int numRows = matrix.length;
+    int numCols = matrix[0].length;
+    int[] rowMin = new int[numRows];
+    int[] colMax = new int[numCols];
+    Arrays.fill(rowMin, Integer.MAX_VALUE);
+    for (int i = 0; i < numRows; i++) {
+      for (int j = 0; j < numCols; j++) {
+        rowMin[i] = Math.min(matrix[i][j], rowMin[i]);
+        colMax[j] = Math.max(matrix[i][j], colMax[j]);
+      }
+    }
+    List<Integer> list = new ArrayList<>();
+    for (int i = 0; i < numRows; i++) {
+      for (int j = 0; j < numCols; j++) {
+        if (rowMin[i] == colMax[j]) {
+          list.add(matrix[i][j]);
+        }
+      }
+    }
+    return list;
+  }
+}
diff --git a/Medium/Clone Binary Tree With Random Pointer.java b/Medium/Clone Binary Tree With Random Pointer.java
new file mode 100644
index 00000000..922389ca
--- /dev/null
+++ b/Medium/Clone Binary Tree With Random Pointer.java	
@@ -0,0 +1,47 @@
+/**
+ * Definition for a binary tree node.
+ * public class Node {
+ *     int val;
+ *     Node left;
+ *     Node right;
+ *     Node random;
+ *     Node() {}
+ *     Node(int val) { this.val = val; }
+ *     Node(int val, Node left, Node right, Node random) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *         this.random = random;
+ *     }
+ * }
+ */
+class Solution {
+  Map<Node, NodeCopy> copyMap;
+  public NodeCopy copyRandomBinaryTree(Node root) {
+    copyMap = new HashMap<>();
+    fillMapTraverse(root);
+    cloneMapTraverse(root);
+    return copyMap.get(root);
+  }
+  
+  private void cloneMapTraverse(Node root) {
+    if (root == null) {
+      return;
+    }
+    NodeCopy copy = copyMap.get(root);
+    copy.left = copyMap.get(root.left);
+    copy.right = copyMap.get(root.right);
+    copy.random = copyMap.get(root.random);
+    cloneMapTraverse(root.left);
+    cloneMapTraverse(root.right);
+  }
+  
+  private void fillMapTraverse(Node root) {
+    if (root == null) {
+      return;
+    }
+    copyMap.put(root, new NodeCopy(root.val));
+    fillMapTraverse(root.left);
+    fillMapTraverse(root.right);
+  }
+}

From afba1dba3edec2bb7a311018f7da13837cfa009b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 21 Jun 2020 14:39:29 -0500
Subject: [PATCH 0198/2175] Added 2 solutions

---
 Medium/Making File Names Unique.java | 27 +++++++++++++++++++++++++++
 Medium/Print Words Vertically.java   | 23 +++++++++++++++++++++++
 2 files changed, 50 insertions(+)
 create mode 100644 Medium/Making File Names Unique.java
 create mode 100644 Medium/Print Words Vertically.java

diff --git a/Medium/Making File Names Unique.java b/Medium/Making File Names Unique.java
new file mode 100644
index 00000000..5ec1113b
--- /dev/null
+++ b/Medium/Making File Names Unique.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public String[] getFolderNames(String[] names) {
+    int n = names.length;
+    Map<String, Integer> map = new HashMap<>();
+    String[] ans = new String[n];
+    for (int i = 0; i < n; i++) {
+      if (map.containsKey(names[i])) {
+        Integer val = map.get(names[i]);
+        StringBuilder sb = new StringBuilder(names[i]);
+        sb.append('(').append(val).append(')');
+        while (map.containsKey(sb.toString())) {
+          val++;
+          sb = new StringBuilder(names[i]);
+          sb.append('(').append(val).append(')');
+        }
+        ans[i] = sb.toString();
+        map.put(sb.toString(), 1);
+        map.put(names[i], val + 1);
+      }
+      else {
+        ans[i] = names[i];
+        map.put(names[i], 1);
+      }
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Print Words Vertically.java b/Medium/Print Words Vertically.java
new file mode 100644
index 00000000..722c9430
--- /dev/null
+++ b/Medium/Print Words Vertically.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public List<String> printVertically(String s) {
+    String[] words = s.split("\\s+");
+    int longestWordLength = 0;
+    for (String word : words) {
+      longestWordLength = Math.max(longestWordLength, word.length());
+    }
+    List<String> ans = new ArrayList<>();
+    for (int i = 0; i < longestWordLength; i++) {
+      StringBuilder sb = new StringBuilder();
+      for (String word : words) {
+        sb.append(i < word.length() ? word.charAt(i) : " ");
+      }
+      while (sb.charAt(sb.length() - 1) == ' ') {
+        sb.deleteCharAt(sb.length() - 1);
+      }
+      if (sb.length() > 0) {
+        ans.add(sb.toString());
+      }
+    }
+    return ans;
+  }
+}

From 6752a399a2a053654afc09443ccc97b3a1faec86 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 22 Jun 2020 13:58:35 -0500
Subject: [PATCH 0199/2175] Modified 4 solutions

---
 Easy/Reverse Vowels of a String.java | 46 +++++++++----------
 Hard/Robot Room Cleaner.java         | 69 +++++++++++-----------------
 Medium/Design File System.java       | 69 ++++++++++++++++++++--------
 Medium/Single Number II.java         | 22 ++++-----
 4 files changed, 107 insertions(+), 99 deletions(-)

diff --git a/Easy/Reverse Vowels of a String.java b/Easy/Reverse Vowels of a String.java
index b5202be8..c1ea0294 100644
--- a/Easy/Reverse Vowels of a String.java	
+++ b/Easy/Reverse Vowels of a String.java	
@@ -1,28 +1,24 @@
 class Solution {
-    public String reverseVowels(String s) {
-        ArrayList<Integer> indexArr = new ArrayList<Integer>();
-        String vowel = "aeiouAEIOU";
-        char[] charArray = s.toCharArray();
-        
-        for (int i=0;i<charArray.length;i++) {
-            if (vowel.indexOf(charArray[i]) != -1) {
-                indexArr.add(i);
-            }
-        }
-
-        int end = indexArr.size()-1;
-        
-        for (int i=0;i<indexArr.size();i++) {
-            int ind = indexArr.get(i);
-            if (ind != -1) {
-                char temp = charArray[ind];
-                charArray[ind] = charArray[indexArr.get(end)];
-                charArray[indexArr.get(end)] = temp;
-                indexArr.set(end, -1);
-                end--;
-            }
-        }
-
-        return new String(charArray);
+  public String reverseVowels(String s) {
+    int left = 0;
+    int right = s.length() - 1;
+    String vowels = "aeiouAEIOU";
+    char[] chars = s.toCharArray();
+    while (left < right) {
+      int vowelIndexLeft = vowels.indexOf(chars[left]);
+      int vowelIndexRight = vowels.indexOf(chars[right]);
+      if (vowelIndexLeft != -1 && vowelIndexRight != -1) {
+        char temp = chars[left];
+        chars[left++] = chars[right];
+        chars[right--] = temp;
+      }
+      else if (vowelIndexRight == -1) {
+        right--;
+      }
+      else {
+        left++;
+      }
     }
+    return String.valueOf(chars);
+  }
 }
diff --git a/Hard/Robot Room Cleaner.java b/Hard/Robot Room Cleaner.java
index aa4cfae6..ece02018 100644
--- a/Hard/Robot Room Cleaner.java	
+++ b/Hard/Robot Room Cleaner.java	
@@ -16,48 +16,33 @@
  * }
  */
 class Solution {
-    public void cleanRoom(Robot robot) {
-        Set<String> visited = new HashSet<>();
-        backtrack(robot, visited, 0, 0, 0);
+  int[][] dirs = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
+  public void cleanRoom(Robot robot) {
+    Set<String> set = new HashSet<>();
+    int currX = 0;
+    int currY = 0;
+    helper(robot, currX, currY, 0, set);
+  }
+  
+  private void helper(Robot robot, int x, int y, int dir, Set<String> set) {
+    if (set.contains(x + "|" + y)) {
+      return;
     }
-    
-    private void backtrack(Robot robot, Set<String> visited, int x, int y, int dir) {
-        String key = x + "|" + y;
-        if (visited.contains(key)) {
-            return;
-        }
-        
-        visited.add(key);
-        robot.clean();
-        
-        for (int k = 0; k < 4; k++) {
-            int i = x;
-            int j = y;
-            if (robot.move()) {
-                if (dir == 0) {
-                    i = x - 1;
-                }
-                else if (dir == 1) {
-                    j = y + 1;
-                }
-                else if (dir == 2) {
-                    i = x + 1;
-                }
-                else {
-                    j = y - 1;
-                }
-                
-                backtrack(robot, visited, i, j, dir);
-                robot.turnLeft();
-                robot.turnLeft();
-                robot.move();
-                robot.turnRight();
-                robot.turnRight();
-            }
-            
-            robot.turnRight();
-            dir += 1;
-            dir %= 4;
-        }
+    set.add(x + "|" + y);
+    robot.clean();
+    for (int i = 0; i < 4; i++) {
+      if (robot.move()) {
+        int newX = x + dirs[dir][0];
+        int newY = y + dirs[dir][1];
+        helper(robot, newX, newY, dir, set);
+        robot.turnLeft();
+        robot.turnLeft();
+        robot.move();
+        robot.turnRight();
+        robot.turnRight();
+      }
+      robot.turnRight();
+      dir = (dir + 1) % 4;
     }
+  }
 }
diff --git a/Medium/Design File System.java b/Medium/Design File System.java
index 9dbb0b39..91a8dccb 100644
--- a/Medium/Design File System.java	
+++ b/Medium/Design File System.java	
@@ -1,30 +1,63 @@
 class FileSystem {
+  FileNode root;
+  public FileSystem() {
+    root = new FileNode("-");
+  }
 
-    Map<String, Integer> map;
-    public FileSystem() {
-        map = new HashMap<>();
-    }
-    
-    public boolean create(String path, int value) {
-        if (map.containsKey(path)) {
-            return false;
+  public boolean createPath(String path, int value) {
+    FileNode curr = root;
+    String[] directories = path.split("/");
+    for (int i = 0; i < directories.length; i++) {
+      if (directories[i].equals("")) {
+        continue;
+      }
+      if (!curr.children.containsKey(directories[i])) {
+        if (i != directories.length - 1) {
+          return false;
         }
-        int lastIdx = path.lastIndexOf('/');
-        if (lastIdx != 0 && !map.containsKey(path.substring(0, lastIdx))) {
-            return false;
-        }    
-        map.put(path, value);
-        return true;
+        curr.children.put(directories[i], new FileNode(directories[i]));
+      }
+      curr = curr.children.get(directories[i]);
+    }
+    if (curr.val != -1) {
+      return false;
     }
-    
-    public int get(String path) {
-        return map.getOrDefault(path, -1);
+    curr.val = value;
+    return true;
+  }
+
+  public int get(String path) {
+    FileNode curr = root;
+    String[] directories = path.split("/");
+    for (int i = 0; i < directories.length; i++) {
+      if (directories[i].equals("")) {
+        continue;
+      }
+      if (!curr.children.containsKey(directories[i])) {
+        return -1;
+      }
+      curr = curr.children.get(directories[i]);
     }
+    return curr.val;
+  }
+}
+
+
+class FileNode {
+  String fileName;
+  int val;
+  Map<String, FileNode> children;
+  
+  public FileNode(String fileName) {
+    this.fileName = fileName;
+    val = -1;
+    children = new HashMap<>();
+  }
 }
 
 /**
  * Your FileSystem object will be instantiated and called as such:
  * FileSystem obj = new FileSystem();
- * boolean param_1 = obj.create(path,value);
+ * boolean param_1 = obj.createPath(path,value);
  * int param_2 = obj.get(path);
  */
diff --git a/Medium/Single Number II.java b/Medium/Single Number II.java
index da4217ff..9c69a1f0 100644
--- a/Medium/Single Number II.java	
+++ b/Medium/Single Number II.java	
@@ -1,17 +1,11 @@
 class Solution {
-    public int singleNumber(int[] nums) {
-        Map<Integer, Integer> map = new HashMap<>();
-        
-        for (int i=0;i<nums.length;i++) {
-            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
-        }
-        
-        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            if (entry.getValue() != 3) {
-                return entry.getKey();
-            }
-        }
-        
-        return -1;
+  public int singleNumber(int[] nums) {
+    int seenOnce = 0;
+    int seenTwice = 0;
+    for (int num : nums) {
+      seenOnce = ~seenTwice & (seenOnce ^ num);
+      seenTwice = ~seenOnce & (seenTwice ^ num);
     }
+    return seenOnce;
+  }
 }

From 0e1f61b7a26035d1a7c4bbe61cc3baeea08c06d1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 22 Jun 2020 17:49:31 -0500
Subject: [PATCH 0200/2175] Added Delete Columns to Make Sorted.java

---
 Easy/Delete Columns to Make Sorted.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Delete Columns to Make Sorted.java

diff --git a/Easy/Delete Columns to Make Sorted.java b/Easy/Delete Columns to Make Sorted.java
new file mode 100644
index 00000000..8cece5a2
--- /dev/null
+++ b/Easy/Delete Columns to Make Sorted.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int minDeletionSize(String[] A) {
+    int numRows = A.length;
+    int numCols = A[0].length();
+    int numDeletions = 0;
+    for (int i = 0; i < numCols; i++) {
+      for (int j = 1; j < numRows; j++) {
+        if (A[j].charAt(i) < A[j - 1].charAt(i)) {
+          numDeletions++;
+          break;
+        }
+      }
+    }
+    return numDeletions;
+  }
+}

From b0f3f137dc1bd6688970bfbff35493fdf6e5309e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 24 Jun 2020 09:49:16 -0500
Subject: [PATCH 0201/2175] Modified 4 solutions

---
 Easy/Longest Univalue Path.java         | 42 +++++++++++++++--------
 Easy/Range Sum Query_Immutable.java     | 22 ++++++-------
 Easy/Read N characters Given Read4.java | 44 ++++++++++++-------------
 Medium/Unique Binary Search Trees.java  | 23 ++++++-------
 4 files changed, 71 insertions(+), 60 deletions(-)

diff --git a/Easy/Longest Univalue Path.java b/Easy/Longest Univalue Path.java
index 5d152248..4409e7bf 100644
--- a/Easy/Longest Univalue Path.java	
+++ b/Easy/Longest Univalue Path.java	
@@ -4,23 +4,37 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    
-    public int longestUnivaluePath(TreeNode root) {
-        int[] res = new int[1];
-        if (root != null) dfs(root, res);
-        return res[0];
+  public int longestUnivaluePath(TreeNode root) {
+    int[] max = {0};
+    helper(root, max);
+    return max[0];
+  }
+  
+  private int helper(TreeNode root, int[] max) {
+    if (root == null) {
+      return 0;
     }
-
-    private int dfs(TreeNode node, int[] res) {
-        int l = node.left != null ? dfs(node.left, res) : 0;
-        int r = node.right != null ? dfs(node.right, res) : 0;
-        int resl = node.left != null && node.left.val == node.val ? l + 1 : 0;
-        int resr = node.right != null && node.right.val == node.val ? r + 1 : 0;
-        res[0] = Math.max(res[0], resl + resr);
-        return Math.max(resl, resr);
+    int left = helper(root.left, max);
+    int right = helper(root.right, max);
+    int leftVal = 0;
+    int rightVal = 0;
+    if (root.left != null && root.val == root.left.val) {
+      leftVal = left + 1;
     }
+    if (root.right != null && root.val == root.right.val) {
+      rightVal = right + 1;
+    }
+    max[0] = Math.max(max[0], leftVal + rightVal);
+    return Math.max(leftVal, rightVal);
+  }
 }
diff --git a/Easy/Range Sum Query_Immutable.java b/Easy/Range Sum Query_Immutable.java
index 38beec52..9a5b7fc8 100644
--- a/Easy/Range Sum Query_Immutable.java	
+++ b/Easy/Range Sum Query_Immutable.java	
@@ -1,21 +1,21 @@
 class NumArray {
-  int[] rangeSum;
+  int[] cumulativeSum;
+  int n;
   public NumArray(int[] nums) {
-    rangeSum = new int[nums.length];
-    int sum = 0;
-    for (int i = 0; i < nums.length; i++) {
-      sum += nums[i];
-      rangeSum[i] = sum;
+    n = nums.length;
+    cumulativeSum = new int[n];
+    int currSum = 0;
+    for (int i = 0; i < n; i++) {
+      currSum += nums[i];
+      cumulativeSum[i] = currSum;
     }
   }
 
   public int sumRange(int i, int j) {
-    int currSum = rangeSum[j];
-    int endIdx = i - 1;
-    if (endIdx >= 0) {
-      currSum -= rangeSum[endIdx];
+    if (i == 0) {
+      return cumulativeSum[j];
     }
-    return currSum;
+    return cumulativeSum[j] - cumulativeSum[i - 1];
   }
 }
 
diff --git a/Easy/Read N characters Given Read4.java b/Easy/Read N characters Given Read4.java
index 69eae7c2..2ba3d5a6 100644
--- a/Easy/Read N characters Given Read4.java	
+++ b/Easy/Read N characters Given Read4.java	
@@ -1,26 +1,26 @@
-/* The read4 API is defined in the parent class Reader4.
-      int read4(char[] buf); */
+/**
+ * The read4 API is defined in the parent class Reader4.
+ *     int read4(char[] buf);
+ */
 
 public class Solution extends Reader4 {
-    /**
-     * @param buf Destination buffer
-     * @param n   Maximum number of characters to read
-     * @return    The number of characters read
-     */
-    public int read(char[] buf, int n) {
-        int count = 0;
-        int total = 0;
-        int read = 4;
-        while(total <= n && read == 4){
-            char[] temp = new char[4];  
-            read = read4(temp); 
-            total += read;
-
-            for(int i = 0; i < read && count < n; i++) {
-                buf[count++] = temp[i];
-            }
-        }
-        
-        return count;
+  /**
+   * @param buf Destination buffer
+   * @param n   Number of characters to read
+   * @return    The number of actual characters read
+   */
+  public int read(char[] buf, int n) {
+    boolean endOfFile = false;
+    int totalLength = 0;
+    char[] temp = new char[4];
+    while (!endOfFile && totalLength < n) {
+      int count = read4(temp);
+      endOfFile = count < 4;
+      count = Math.min(count, n - totalLength);
+      for (int i = 0; i < count; i++) {
+        buf[totalLength++] = temp[i];
+      }
     }
+    return totalLength;
+  }
 }
diff --git a/Medium/Unique Binary Search Trees.java b/Medium/Unique Binary Search Trees.java
index ceefcd1f..66c730d2 100644
--- a/Medium/Unique Binary Search Trees.java	
+++ b/Medium/Unique Binary Search Trees.java	
@@ -1,16 +1,13 @@
 class Solution {
-    public int numTrees(int n) {
-        int[] store = new int[n + 1];
-        
-        store[0] = 1;
-        store[1] = 1;
-        
-        for (int i = 2; i <= n; i++) {
-            for (int j = 1; j <= i; j++) {
-                store[i] += store[j - 1] * store[i - j];
-            }
-        }
-        
-        return store[n];
+  public int numTrees(int n) {
+    int[] dp = new int[n + 1];
+    dp[0] = 1;
+    dp[1] = 1;
+    for (int i = 2; i <= n; i++) {
+      for (int j = 1; j <= i; j++) {
+        dp[i] += dp[j - 1] * dp[i - j];
+      }
     }
+    return dp[n];
+  }
 }

From 91b38ae66c1e09c18410436a60d8f66230ddb537 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 24 Jun 2020 17:03:15 -0500
Subject: [PATCH 0202/2175] Modified 5 solutions

---
 Easy/Min Cost Climbing Stairs.java       | 17 ++++---
 Easy/Remove Element.java                 | 14 ++++++
 Easy/Sum of left leaves.java             | 41 ++++++++++-------
 Easy/remove_element.java                 | 17 -------
 Medium/Combination Sum.java              | 56 +++++++++---------------
 Medium/Range Sum Query 2D-Immutable.java | 55 +++++++----------------
 6 files changed, 88 insertions(+), 112 deletions(-)
 create mode 100644 Easy/Remove Element.java
 delete mode 100644 Easy/remove_element.java

diff --git a/Easy/Min Cost Climbing Stairs.java b/Easy/Min Cost Climbing Stairs.java
index 2f6a50fb..7a718918 100644
--- a/Easy/Min Cost Climbing Stairs.java	
+++ b/Easy/Min Cost Climbing Stairs.java	
@@ -1,10 +1,13 @@
 class Solution {
-    public int minCostClimbingStairs(int[] cost) {
-        int[] dp = new int[cost.length + 1];
-        
-        for (int i = 2; i <= cost.length; i++)
-            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
-        
-        return dp[cost.length];
+  public int minCostClimbingStairs(int[] cost) {
+    int n = cost.length;
+    int first = cost[0];
+    int second = cost[1];
+    for (int i = 2; i < n; i++) {
+      int curr = cost[i] + Math.min(first, second);
+      first = second;
+      second = curr;
     }
+    return Math.min(first, second);
+  }
 }
diff --git a/Easy/Remove Element.java b/Easy/Remove Element.java
new file mode 100644
index 00000000..f879483d
--- /dev/null
+++ b/Easy/Remove Element.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int removeElement(int[] nums, int val) {
+    int start = 0;
+    int end = 0;
+    int n = nums.length;
+    while (end < n) {
+      if (nums[end] != val) {
+        nums[start++] = nums[end];
+      }
+      end++;
+    }
+    return start;
+  }
+}
diff --git a/Easy/Sum of left leaves.java b/Easy/Sum of left leaves.java
index d0f6e832..96ebf76b 100644
--- a/Easy/Sum of left leaves.java	
+++ b/Easy/Sum of left leaves.java	
@@ -4,23 +4,34 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int sumOfLeftLeaves(TreeNode root) {
-        if (root == null) return 0;
-        int ans = 0;
-        if(root.left != null) {
-            if(root.left.left == null && root.left.right == null) {
-                ans += root.left.val;
-            }
-            else {
-                ans += sumOfLeftLeaves(root.left);
-            }
-        }
-        ans += sumOfLeftLeaves(root.right);
-
-        return ans;
+  public int sumOfLeftLeaves(TreeNode root) {
+    int[] sum = {0};
+    helper(root, null, sum);
+    return sum[0];
+  } 
+  
+  private void helper(TreeNode root, TreeNode parent, int[] sum) {
+    if (root == null) {
+      return;
     }
+    if (root.left == null && root.right == null) {
+      if (parent != null && parent.left == root) {
+        sum[0] += root.val;
+      }
+    }
+    else {
+      helper(root.left, root, sum);
+      helper(root.right, root, sum);
+    }
+  }
 }
diff --git a/Easy/remove_element.java b/Easy/remove_element.java
deleted file mode 100644
index a01de9eb..00000000
--- a/Easy/remove_element.java
+++ /dev/null
@@ -1,17 +0,0 @@
-public class Solution {
-	public int removeElement(int[] A, int elem) {
-    int i=0;
-    int j=0;
- 
-    while(j < A.length){
-        if(A[j] != elem){
-            A[i] = A[j];
-            i++; 
-        }
- 
-        j++;
-    }
- 
-    return i;
-}
-}
\ No newline at end of file
diff --git a/Medium/Combination Sum.java b/Medium/Combination Sum.java
index 4e116b8e..4496b970 100644
--- a/Medium/Combination Sum.java	
+++ b/Medium/Combination Sum.java	
@@ -1,38 +1,24 @@
 class Solution {
-    Set<List<Integer>> set;
-    public List<List<Integer>> combinationSum(int[] candidates, int target) {
-        set = new HashSet<>();
-        Arrays.sort(candidates);
-        combinationSumHelper(candidates, 0, target, new ArrayList<>());
-        
-        return new ArrayList<>(set);
+  List<List<Integer>> list;
+  public List<List<Integer>> combinationSum(int[] candidates, int target) {
+    list = new ArrayList<>();
+    helper(candidates, 0, target, 0, new ArrayList<>());
+    return list;
+  }
+  
+  private void helper(int[] candidates, int idx, int target, int currSum, List<Integer> temp) {
+    if (currSum == target) {
+      list.add(new ArrayList<>(temp));
     }
-    
-    private void combinationSumHelper(int[] candidates, int currVal, int target, List<Integer> list) {
-        if (currVal == target) {
-            set.add(new ArrayList<>(list));
-            return;
-        }
-        
-        if (currVal > target) {
-            return;
-        }
-        
-        for (int i = 0; i < candidates.length; i++) {
-            if (list.size() > 0 && list.get(list.size() - 1) > candidates[i]) {
-                continue;
-            }
- 
-            // Choose
-            currVal += candidates[i];
-            list.add(candidates[i]);
-            
-            // Explore
-            combinationSumHelper(candidates, currVal, target, list);
-            
-            // Unchoose
-            list.remove(list.size() - 1);
-            currVal -= candidates[i];
-        }
-    } 
+    else if (idx == candidates.length || currSum > target) {
+      return;
+    }
+    else {
+      for (int i = idx; i < candidates.length; i++) {
+        temp.add(candidates[i]);
+        helper(candidates, i, target, currSum + candidates[i], temp);
+        temp.remove(temp.size() - 1);
+      }
+    }
+  }
 }
diff --git a/Medium/Range Sum Query 2D-Immutable.java b/Medium/Range Sum Query 2D-Immutable.java
index ad98e625..9139dcef 100644
--- a/Medium/Range Sum Query 2D-Immutable.java	
+++ b/Medium/Range Sum Query 2D-Immutable.java	
@@ -1,45 +1,24 @@
 class NumMatrix {
-    int[][] dp;
-    int[][] matrix;
-    public NumMatrix(int[][] matrix) {
-        this.matrix = matrix;
-        if (matrix.length == 0) {
-            dp = new int[0][0];
-            return;
-        }
-        
-        dp = new int[matrix.length][matrix[0].length];
-        fillDpArray();
-        
-        for (int[] arr : dp) {
-            System.out.println(Arrays.toString(arr));
-        }
+  int[][] dp;
+  public NumMatrix(int[][] matrix) {
+    if (matrix.length == 0 || matrix[0].length == 0) {
+      return;
     }
-    
-    private void fillDpArray() {
-        int row = matrix.length;
-        int col = matrix[0].length;
-        
-        for (int i = 0; i < row; i++) {
-            int sum = 0;
-            for (int j = 0; j < col; j++) {
-                sum += this.matrix[i][j];
-                dp[i][j] = sum;
-            }
-        }
+    dp = new int[matrix.length][matrix[0].length + 1];
+    for (int i = 0; i < matrix.length; i++) {
+      for (int j = 0; j < matrix[0].length; j++) {
+        dp[i][j + 1] = dp[i][j] + matrix[i][j];
+      }
     }
-    
-    public int sumRegion(int row1, int col1, int row2, int col2) {
-        int currSum = 0;
-        for (int i = row1; i <= row2; i++) {
-            currSum += dp[i][col2];
-            if (col1 != 0) {
-                currSum -= dp[i][col1 - 1];
-            }
-        }   
-        
-        return currSum;
+  }
+
+  public int sumRegion(int row1, int col1, int row2, int col2) {
+    int sum = 0;
+    for (int row = row1; row <= row2; row++) {
+      sum += dp[row][col2 + 1] - dp[row][col1];
     }
+    return sum;
+  }
 }
 
 /**

From 40b21a07a5fd6a710358616251e007d92fd0de0f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 25 Jun 2020 16:47:07 -0500
Subject: [PATCH 0203/2175] Added 1 solution & modified 3 solutions

---
 Easy/Shortest Word Distance II.java    | 47 --------------------------
 Easy/Shortest Word Distance III.java   | 43 -----------------------
 Easy/Shortest Word Distance.java       | 36 +++++++++-----------
 Medium/HTML Entity Parser.java         | 18 ++++++++++
 Medium/Shortest Word Distance II.java  | 33 ++++++++++++++++++
 Medium/Shortest Word Distance III.java | 40 ++++++++++++++++++++++
 6 files changed, 107 insertions(+), 110 deletions(-)
 delete mode 100644 Easy/Shortest Word Distance II.java
 delete mode 100644 Easy/Shortest Word Distance III.java
 create mode 100644 Medium/HTML Entity Parser.java
 create mode 100644 Medium/Shortest Word Distance II.java
 create mode 100644 Medium/Shortest Word Distance III.java

diff --git a/Easy/Shortest Word Distance II.java b/Easy/Shortest Word Distance II.java
deleted file mode 100644
index 8cf6497e..00000000
--- a/Easy/Shortest Word Distance II.java	
+++ /dev/null
@@ -1,47 +0,0 @@
-class WordDistance {
-
-    Map<String, List<Integer>> map;
-    public WordDistance(String[] words) {
-        map = new HashMap<>();
-
-        for (int i=0; i<words.length; i++) {
-            if (map.containsKey(words[i])) {
-                map.get(words[i]).add(i);
-            }
-            else {
-                List<Integer> indexes = new ArrayList<>();
-                indexes.add(i);
-
-                map.put(words[i], indexes);
-            }
-        }
-    }
-
-    public int shortest(String word1, String word2) {
-        List<Integer> index1 = map.get(word1);
-        List<Integer> index2 = map.get(word2);
-
-        int i = 0;
-        int j = 0;
-        int diff = Integer.MAX_VALUE;
-
-        while (i < index1.size() && j < index2.size()) {
-            diff = Math.min(diff, Math.abs(index1.get(i) - index2.get(j)));
-
-            if (index1.get(i) > index2.get(j)) {
-                j++;
-            }
-            else {
-                i++;
-            }
-        }
-
-        return diff;
-    }
-}
-
-/**
- * Your WordDistance object will be instantiated and called as such:
- * WordDistance obj = new WordDistance(words);
- * int param_1 = obj.shortest(word1,word2);
- */
diff --git a/Easy/Shortest Word Distance III.java b/Easy/Shortest Word Distance III.java
deleted file mode 100644
index 3b05dcee..00000000
--- a/Easy/Shortest Word Distance III.java	
+++ /dev/null
@@ -1,43 +0,0 @@
-class Solution {
-    public int shortestWordDistance(String[] words, String word1, String word2) {
-        int dist1 = -1;
-        int dist2 = -1;
-        int minDist = Integer.MAX_VALUE;
-        
-        boolean sameWord = word1.equals(word2);
-        
-        for (int i=0; i<words.length; i++) {
-            if (words[i].equals(word1)) {
-                if (sameWord) {
-                    if (dist1 == -1) {
-                        dist1 = i;
-                    }
-                }
-                else {
-                    dist1 = i;
-                }
-            }
-            
-            if (words[i].equals(word2)) { 
-                if (sameWord) {
-                    if (i != dist1) {
-                        dist2 = i;
-                    }
-                }
-                else {
-                    dist2 = i;
-                }
-            }
-            
-            if (dist1 != -1 && dist2 != -1) {
-                minDist = Math.min(minDist, Math.abs(dist1 - dist2));
-                if (sameWord) {
-                    dist1 = dist2;
-                    dist2 = -1;
-                }
-            }
-        }
-        
-        return minDist;
-    }
-}
diff --git a/Easy/Shortest Word Distance.java b/Easy/Shortest Word Distance.java
index e5fdacc2..24945f35 100644
--- a/Easy/Shortest Word Distance.java	
+++ b/Easy/Shortest Word Distance.java	
@@ -1,23 +1,19 @@
 class Solution {
-    public int shortestDistance(String[] words, String word1, String word2) {
-        int dist1 = -1;
-        int dist2 = -1;
-        int minDist = Integer.MAX_VALUE;
-        
-        for (int i=0; i<words.length; i++) {
-            if (words[i].equals(word1)) {
-                dist1 = i;
-            }
-            
-            if (words[i].equals(word2)) {
-                dist2 = i;
-            }
-            
-            if (dist1 != -1 && dist2 != -1) {
-                minDist = Math.min(minDist, Math.abs(dist1 - dist2));
-            }
-        }
-        
-        return minDist;
+  public int shortestDistance(String[] words, String word1, String word2) {
+    int idx1 = -1;
+    int idx2 = -1;
+    int minDistance = words.length;
+    for (int i = 0; i < words.length; i++) {
+      if (words[i].equals(word1)) {
+        idx1 = i;
+      }
+      else if (words[i].equals(word2)) {
+        idx2 = i;
+      }
+      if (idx1 != -1 && idx2 != -1) {
+        minDistance = Math.min(minDistance, Math.abs(idx1 - idx2));
+      }
     }
+    return minDistance;
+  }
 }
diff --git a/Medium/HTML Entity Parser.java b/Medium/HTML Entity Parser.java
new file mode 100644
index 00000000..1e070ddd
--- /dev/null
+++ b/Medium/HTML Entity Parser.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public String entityParser(String text) {
+    if (text == null || text.length() == 0) {
+      return "";
+    }
+    Map<String, String> map = Map.of(
+      "&quot;", "\"", 
+      "&apos;", "'", 
+      "&gt;", ">", 
+      "&lt;", "<", 
+      "&frasl;", "/"
+    );
+    for (String key : map.keySet()) {
+      text = text.replaceAll(key, map.get(key));
+    }
+    return text.replaceAll("&amp;", "&");
+  }
+}
diff --git a/Medium/Shortest Word Distance II.java b/Medium/Shortest Word Distance II.java
new file mode 100644
index 00000000..7dbb3799
--- /dev/null
+++ b/Medium/Shortest Word Distance II.java	
@@ -0,0 +1,33 @@
+class WordDistance {
+  Map<String, List<Integer>> map;
+  public WordDistance(String[] words) {
+    map = new HashMap<>();
+    for (int i = 0; i < words.length; i++) {
+      map.computeIfAbsent(words[i], k -> new ArrayList<>()).add(i);
+    }
+  }
+
+  public int shortest(String word1, String word2) {
+    List<Integer> idxList1 = map.get(word1);
+    List<Integer> idxList2 = map.get(word2);
+    int idx1 = 0;
+    int idx2 = 0;
+    int minDiff = Math.abs(idxList1.get(idx1) - idxList2.get(idx2));
+    while (idx1 < idxList1.size() && idx2 < idxList2.size()) {
+      minDiff = Math.min(minDiff, Math.abs(idxList1.get(idx1) - idxList2.get(idx2)));
+      if (idxList1.get(idx1) < idxList2.get(idx2)) {
+        idx1++;
+      }
+      else {
+        idx2++;
+      }
+    }
+    return minDiff;
+  }
+}
+
+/**
+ * Your WordDistance object will be instantiated and called as such:
+ * WordDistance obj = new WordDistance(words);
+ * int param_1 = obj.shortest(word1,word2);
+ */
diff --git a/Medium/Shortest Word Distance III.java b/Medium/Shortest Word Distance III.java
new file mode 100644
index 00000000..f2b40359
--- /dev/null
+++ b/Medium/Shortest Word Distance III.java	
@@ -0,0 +1,40 @@
+class Solution {
+  public int shortestWordDistance(String[] words, String word1, String word2) {
+    int idx1 = -1;
+    int idx2 = -1;
+    boolean sameWord = word1.equals(word2);
+    int n = words.length;
+    int minDiff = Integer.MAX_VALUE;
+    for (int i = 0; i < words.length; i++) {
+      if (words[i].equals(word1)) {
+        if (sameWord) {
+          if (idx1 == -1) {
+            idx1 = i;
+          }
+        }
+        else {
+          idx1 = i;
+        }
+      }
+      if (words[i].equals(word2)) {
+        if (sameWord) {
+          if (idx1 != i) {
+            idx2 = i;
+          }
+        }
+        else {
+          idx2 = i;
+        }
+      }
+      if (idx1 != -1 && idx2 != -1) {
+        minDiff = Math.min(minDiff, Math.abs(idx1 - idx2));
+        if (sameWord) {
+          idx1 = idx2;
+          idx2 = -1;
+        }
+      }
+    }
+    return minDiff;
+  }
+}
+

From 5a6946db15fed27298b1d6063facd31eda933183 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 26 Jun 2020 15:17:19 -0500
Subject: [PATCH 0204/2175] Added Clone N-ary Tree.java

---
 Medium/Clone N-ary Tree.java | 66 ++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 Medium/Clone N-ary Tree.java

diff --git a/Medium/Clone N-ary Tree.java b/Medium/Clone N-ary Tree.java
new file mode 100644
index 00000000..3943e23c
--- /dev/null
+++ b/Medium/Clone N-ary Tree.java	
@@ -0,0 +1,66 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    
+    public Node() {
+        children = new ArrayList<Node>();
+    }
+    
+    public Node(int _val) {
+        val = _val;
+        children = new ArrayList<Node>();
+    }
+    
+    public Node(int _val,ArrayList<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+  public Node cloneTree(Node root) {
+    if (root == null) {
+      return null;
+    }
+    Node copy = new Node(root.val);
+    for (Node child : root.children) {
+      copy.children.add(cloneTree(child));
+    }
+    return copy;
+  }
+
+  Map<Node, Node> map;
+  public Node cloneTreeDetailed(Node root) {
+    if (root == null) {
+      return null;
+    }
+    map = new HashMap<>();
+    copyTree(root);
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      Node removed = queue.remove();
+      Node copy = map.get(removed);
+      List<Node> children = removed.children;
+      for (Node child : children) {
+        copy.children.add(map.get(child));
+        queue.add(child);
+      }
+    }
+    return map.get(root);
+  }
+  
+  private void copyTree(Node root) {
+    if (root == null) {
+      return;
+    }
+    map.put(root, new Node(root.val));
+    for (Node child : root.children) {
+      copyTree(child);
+    }
+  }
+}

From e3544dd796ec793fc640e9ac51a3053233250ddc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 27 Jun 2020 10:11:17 -0500
Subject: [PATCH 0205/2175] Modified 2 solutions

---
 Easy/Unique Email Addresses.java | 59 ++++++++++++++++++--------------
 Medium/Fruit Into Baskets.java   | 41 ++++++++++------------
 2 files changed, 51 insertions(+), 49 deletions(-)

diff --git a/Easy/Unique Email Addresses.java b/Easy/Unique Email Addresses.java
index ea794493..871d1a0e 100644
--- a/Easy/Unique Email Addresses.java	
+++ b/Easy/Unique Email Addresses.java	
@@ -1,30 +1,37 @@
 class Solution {
-    public int numUniqueEmails(String[] emails) {
-        return Arrays.stream(emails)
-                    .map(e -> getFormattedEmail(e))
-                    .collect(Collectors.toSet())
-                    .size();
+  public int numUniqueEmails(String[] emails) {
+    Set<String> set = new HashSet<>();
+    for (String email : emails) {
+      set.add(formattedEmail(email));
     }
-    
-    private String getFormattedEmail(String email) {
-        StringBuilder sb = new StringBuilder();
-        int idx = 0;
-        
-        while (idx < email.length()) {
-            if (email.charAt(idx) == '@' || email.charAt(idx) == '+') {
-                break;
-            }
-            if (email.charAt(idx) != '.') {
-                sb.append(email.charAt(idx));
-            }
-            
-            idx++;
-        }
-        
-        while (email.charAt(idx) != '@') {
-            idx++;
-        }
-        
-        return sb.append('@').append(email.substring(idx + 1)).toString();
+    return set.size();
+  }
+  
+  private String formattedEmail(String s) {
+    StringBuilder sb = new StringBuilder();
+    int i = 0;
+    int n = s.length();
+    boolean plusFound = false;
+    while (i < n) {
+      char c = s.charAt(i);
+      if (c == '@') {
+        break;
+      }
+      if (plusFound) {
+        i++;
+        continue;
+      }
+      else if (c == '+') {
+        plusFound = true;
+      }
+      else if (c != '.') {
+        sb.append(c);
+      }
+      i++;
     }
+    while (i < n) {
+      sb.append(s.charAt(i++));
+    }
+    return sb.toString();
+  }
 }
diff --git a/Medium/Fruit Into Baskets.java b/Medium/Fruit Into Baskets.java
index 2cec17aa..ad4dba0b 100644
--- a/Medium/Fruit Into Baskets.java	
+++ b/Medium/Fruit Into Baskets.java	
@@ -1,27 +1,22 @@
 class Solution {
-    public int totalFruit(int[] tree) {
-        Map<Integer, Integer> map = new HashMap<>();
-        int maxSize = 0;
-        int start = 0;
-        int count = 0;
-        
-        for (int i = 0; i < tree.length; i++) {
-            map.put(tree[i], map.getOrDefault(tree[i], 0) + 1);
-            count++;
-            
-            while (map.size() > 2) {
-                map.put(tree[start], map.getOrDefault(tree[start], 0) - 1);
-                if (map.get(tree[start]) == 0) {
-                    map.remove(tree[start]);
-                }
-                
-                count--;
-                start++;
-            }
-            
-            maxSize = Math.max(maxSize, count);
+  public int totalFruit(int[] tree) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int maxCount = 0;
+    int start = 0;
+    int end = 0;
+    int n = tree.length;
+    while (end < n) {
+      map.put(tree[end], map.getOrDefault(tree[end], 0) + 1);
+      while (map.size() > 2) {
+        map.put(tree[start], map.get(tree[start]) - 1);
+        if (map.get(tree[start]) == 0) {
+          map.remove(tree[start]);
         }
-        
-        return maxSize;
+        start++;
+      }
+      end++;
+      maxCount = Math.max(maxCount, end - start);
     }
+    return maxCount;
+  }
 }

From eeeb317abaa7e9342dc7047828ccac24bfabb16e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 28 Jun 2020 09:33:33 -0500
Subject: [PATCH 0206/2175] Added 2 solutions

---
 ...luding the Minimum and Maximum Salary.java | 15 +++++++++++++
 Easy/Path Crossing.java                       | 21 +++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 Easy/Average Salary Excluding the Minimum and Maximum Salary.java
 create mode 100644 Easy/Path Crossing.java

diff --git a/Easy/Average Salary Excluding the Minimum and Maximum Salary.java b/Easy/Average Salary Excluding the Minimum and Maximum Salary.java
new file mode 100644
index 00000000..08d8663e
--- /dev/null
+++ b/Easy/Average Salary Excluding the Minimum and Maximum Salary.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public double average(int[] salary) {
+    int minSalary = salary[0];
+    int maxSalary = salary[0];
+    int n = salary.length;
+    int sum = 0;
+    for (int i = 0; i < n; i++) {
+      sum += salary[i];
+      minSalary = Math.min(minSalary, salary[i]);
+      maxSalary = Math.max(maxSalary, salary[i]);
+    }
+    sum -= (maxSalary + minSalary);
+    return ((double) sum) / (n - 2);
+  }
+}
diff --git a/Easy/Path Crossing.java b/Easy/Path Crossing.java
new file mode 100644
index 00000000..32b241c3
--- /dev/null
+++ b/Easy/Path Crossing.java	
@@ -0,0 +1,21 @@
+class Solution {
+  int[][] dirs = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
+  public boolean isPathCrossing(String path) {
+    Set<String> set = new HashSet<>();
+    int currX = 0;
+    int currY = 0;
+    String dirSymbol = "NSEW";
+    set.add(currX + "|" + currY);
+    for (char c : path.toCharArray()) {
+      int dirIdx = dirSymbol.indexOf(c);
+      currX += dirs[dirIdx][0];
+      currY += dirs[dirIdx][1];
+      String hash = currX + "|" + currY;
+      if (set.contains(hash)) {
+        return true;
+      }
+      set.add(hash);
+    }
+    return false;
+  }
+}

From c4478c6b4d4ae8978868788cc10d89d39cd22fe2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 30 Jun 2020 15:29:14 -0500
Subject: [PATCH 0207/2175] Added 1 solution & modified 1 solution

---
 ...Array Into Three Parts With Equal Sum.java | 22 ++++++
 Medium/Candy Crush.java                       | 67 +++++++++----------
 2 files changed, 53 insertions(+), 36 deletions(-)
 create mode 100644 Easy/Partition Array Into Three Parts With Equal Sum.java

diff --git a/Easy/Partition Array Into Three Parts With Equal Sum.java b/Easy/Partition Array Into Three Parts With Equal Sum.java
new file mode 100644
index 00000000..afcf6574
--- /dev/null
+++ b/Easy/Partition Array Into Three Parts With Equal Sum.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public boolean canThreePartsEqualSum(int[] A) {
+    int totalSum = 0;
+    for (int num : A) {
+      totalSum += num;
+    }
+    if (totalSum % 3 != 0) {
+      return false;
+    }
+    totalSum = totalSum / 3;
+    int currSum = 0;
+    int segmentCount = 0;
+    for (int num : A) {
+      currSum += num;
+      if (currSum == totalSum) {
+        segmentCount++;
+        currSum = 0;
+      }
+    }
+    return segmentCount >= 3;
+  }
+}
diff --git a/Medium/Candy Crush.java b/Medium/Candy Crush.java
index 8e60087e..627ba3bb 100644
--- a/Medium/Candy Crush.java	
+++ b/Medium/Candy Crush.java	
@@ -1,42 +1,37 @@
 class Solution {
-    public int[][] candyCrush(int[][] board) {
-        int rows = board.length;
-        int cols = board[0].length;
-        boolean flag = false;
-        
-        for (int i = 0; i < rows; i++) {
-            for (int j = 0; j + 2 < cols; j++) {
-                int val = Math.abs(board[i][j]);
-                if (val != 0 && val == Math.abs(board[i][j + 1]) && val == Math.abs(board[i][j + 2])) {
-                    board[i][j] = board[i][j + 1] = board[i][j + 2] = -val;
-                    flag = true;
-                }
-            }
+  public int[][] candyCrush(int[][] board) {
+    int rows = board.length;
+    int cols = board[0].length;
+    boolean flag = false;
+    for (int r = 0; r < rows; r++) {
+      for (int c = 0; c + 2 < cols; c++) {
+        int val = Math.abs(board[r][c]);
+        if (val != 0 && val == Math.abs(board[r][c + 1]) && val == Math.abs(board[r][c + 2])) {
+          board[r][c] = board[r][c + 1] = board[r][c + 2] = -val;
+          flag = true;
         }
-        
-        for (int i = 0; i + 2 < rows; i++) {
-            for (int j = 0; j < cols; j++) {
-                int val = Math.abs(board[i][j]);
-                if (val != 0 && val == Math.abs(board[i + 1][j]) && val == Math.abs(board[i + 2][j])) {
-                    board[i][j] = board[i + 1][j] = board[i + 2][j] = -val;
-                    flag = true;
-                }
-            }
+      }
+    }
+    for (int r = 0; r + 2 < rows; r++) {
+      for (int c = 0; c < cols; c++) {
+        int val = Math.abs(board[r][c]);
+        if (val != 0 && val == Math.abs(board[r + 1][c]) && val == Math.abs(board[r + 2][c])) {
+          board[r][c] = board[r + 1][c] = board[r + 2][c] = -val;
+          flag = true;
         }
-        
-        for (int i = 0; i < cols; ++i) {
-            int rightRow = rows - 1;
-            for (int j = rows - 1; j >= 0; --j) {
-                if (board[j][i] > 0) {
-                    board[rightRow--][i] = board[j][i];
-                }
-            }
-            
-            while (rightRow >= 0) {
-                board[rightRow--][i] = 0;
-            }
+      }
+    }
+    for (int c = 0; c < cols; c++) {
+      int currRow = rows - 1;
+      for (int r = rows - 1; r >= 0; r--) {
+        if (board[r][c] > 0) {
+          board[currRow--][c] = board[r][c];
         }
-        
-        return flag ? candyCrush(board) : board;
+      }
+      while (currRow >= 0) {
+        board[currRow--][c] = 0;
+      }
     }
+    return flag ? candyCrush(board) : board;
+  }
 }

From 9f5acc84b9a10709bd5fc424482efa81150a48af Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 1 Jul 2020 15:04:03 -0500
Subject: [PATCH 0208/2175] Added 1 solution & modified 4 solutions

---
 Easy/Arranging Coins.java               | 28 ++++-----
 Easy/Divisor Game.java                  | 18 ++++++
 Easy/Largest Time for Given Digits.java | 26 ++++-----
 Medium/Mini Parser.java                 | 75 +++++++++++++------------
 Medium/Remove Comments.java             | 67 ++++++++++------------
 5 files changed, 112 insertions(+), 102 deletions(-)
 create mode 100644 Easy/Divisor Game.java

diff --git a/Easy/Arranging Coins.java b/Easy/Arranging Coins.java
index 6e5767df..bf2f70fa 100644
--- a/Easy/Arranging Coins.java	
+++ b/Easy/Arranging Coins.java	
@@ -1,20 +1,14 @@
 class Solution {
-    public int arrangeCoins(int n) {
-        long j = 1;
-        long sum = 0;
-    
-        int ans = 0;
-        while (true) {
-            sum += j;
-            if (sum <= n) {
-                ans++;
-            } 
-            else {
-                break;
-            }
-            j++;
-        }
-        
-        return ans;
+  public int arrangeCoins(int n) {
+    int copy = n;
+    int count = 0;
+    for (int i = 1; i <= copy && n > 0; i++) {
+      n -= i;
+      if (n < 0) {
+        break;
+      }
+      count++;
     }
+    return count;
+  }
 }
diff --git a/Easy/Divisor Game.java b/Easy/Divisor Game.java
new file mode 100644
index 00000000..a9b03a25
--- /dev/null
+++ b/Easy/Divisor Game.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public boolean divisorGame(int N) {
+    boolean[] dp = new boolean[N + 1];
+    dp[0] = false;
+    dp[1] = false;
+    for (int i = 2; i <= N; i++) {
+      for (int j = 1; j < i; j++) {
+        if (i % j == 0) {
+          if (dp[i - j] == false) {
+            dp[i] = true;
+            break;
+          }
+        }
+      }
+    }
+    return dp[N];
+  }
+}
diff --git a/Easy/Largest Time for Given Digits.java b/Easy/Largest Time for Given Digits.java
index 1f57f8a5..51ab3232 100644
--- a/Easy/Largest Time for Given Digits.java	
+++ b/Easy/Largest Time for Given Digits.java	
@@ -1,19 +1,19 @@
 class Solution {
   public String largestTimeFromDigits(int[] A) {
     int ans = -1;
-    // Choose different indices i, j, k, l as a permutation of 0, 1, 2, 3
-    for (int i = 0; i < 4; ++i) {
-      for (int j = 0; j < 4; ++j) {
-        if (j != i) {
-          for (int k = 0; k < 4; ++k) {
-            if (k != i && k != j) {
-              int l = 6 - i - j - k;
-              // For each permutation of A[i], read out the time and
-              // record the largest legal time.
-              int hours = 10 * A[i] + A[j];
-              int mins = 10 * A[k] + A[l];
-              if (hours < 24 && mins < 60) {
-                ans = Math.max(ans, hours * 60 + mins);
+    for (int i = 0; i < 4; i++) {
+      for (int j = 0; j < 4; j++) {
+        if (i != j) {
+          for (int k = 0; k < 4; k++) {
+            if (i != k && j != k) {
+              for (int l = 0; l < 4; l++) {
+                if (l != i && l != j && l != k) {
+                  int hours = 10 * A[i] + A[j];
+                  int mins = 10 * A[k] + A[l];
+                  if (hours < 24 && mins < 60) {
+                    ans = Math.max(ans, hours * 60 + mins);
+                  }
+                }
               }
             }
           }
diff --git a/Medium/Mini Parser.java b/Medium/Mini Parser.java
index 6be1808c..a900b446 100644
--- a/Medium/Mini Parser.java	
+++ b/Medium/Mini Parser.java	
@@ -27,41 +27,46 @@
  * }
  */
 class Solution {
-    int idx = 0;
-    public NestedInteger deserialize(String s) {
-        int l = s.length();
-        NestedInteger ans = new NestedInteger();
-        
-        while (idx < l) { 
-            if (s.charAt(idx) == '-' || s.charAt(idx) >= '0' && s.charAt(idx) <= '9') {
-                int num = 0;
-                int sign = 1;
-                
-                if (s.charAt(idx) == '-') {
-                    sign = -1;
-                    idx++;
-                }
-                
-                while (idx < l && s.charAt(idx) >= '0' && s.charAt(idx) <= '9') {
-                    num = num * 10 + (s.charAt(idx) - '0');
-                    idx++;
-                }
-                
-                ans.add(new NestedInteger(num * sign));
-            }
-            else if (s.charAt(idx) == '[') {
-                idx++;
-                ans.add(deserialize(s));
-            }
-            else if (s.charAt(idx) == ']') {
-                idx++;
-                return ans;
-            }
-            else {
-                idx++;
-            }
+  public NestedInteger deserialize(String s) {
+    if (s == null || s.length() == 0) {
+      return null;
+    }
+    if (s.charAt(0) != '[') {
+      return new NestedInteger(Integer.valueOf(s));
+    }
+    Stack<NestedInteger> stack = new Stack<>();
+    NestedInteger curr = null;
+    int start = 0;
+    int n = s.length();
+    for (int end = 0; end < n; end++) {
+      char c = s.charAt(end);
+      if (c == '[') {
+        if (curr != null) {
+          stack.push(curr);
+        }
+        curr = new NestedInteger();
+        start = end + 1;
+      }
+      else if (c == ']') {
+        String num = s.substring(start, end);
+        if (!num.isEmpty()) {
+          curr.add(new NestedInteger(Integer.valueOf(num)));
+        }
+        if (!stack.isEmpty()) {
+          NestedInteger popped = stack.pop();
+          popped.add(curr);
+          curr = popped;
+        }
+        start = end + 1;
+      }
+      else if (c == ',') {
+        if (s.charAt(end - 1) != ']') {
+          String num = s.substring(start, end);
+          curr.add(new NestedInteger(Integer.valueOf(num)));
         }
-        
-        return ans.getList().get(0);
+        start = end + 1;
+      }
     }
+    return curr;
+  }
 }
diff --git a/Medium/Remove Comments.java b/Medium/Remove Comments.java
index 3a9d0bca..e9daac5c 100644
--- a/Medium/Remove Comments.java	
+++ b/Medium/Remove Comments.java	
@@ -1,41 +1,34 @@
 class Solution {
-    public List<String> removeComments(String[] source) {
-        List<String> ans = new ArrayList<>();
-        int i = 0;
-        int n = source.length;
-        boolean blockComment = false;
-        StringBuilder sb = new StringBuilder();
-
-        for (i = 0; i < n; i++) {
-            String line = source[i];
-
-            for (int j = 0; j < line.length(); j++) {
-                if (!blockComment) {
-                    if (j + 1 < line.length() && line.charAt(j) == '/' && line.charAt(j + 1) == '/') {
-                        break;
-                    }
-                    else if (j + 1 < line.length() && line.charAt(j) == '/' && line.charAt(j+1) == '*') {
-                        blockComment = true;
-                        j++;
-                    }
-                    else {
-                        sb.append(line.charAt(j));
-                    }
-                }
-                else {
-                    if (j + 1 < line.length() && line.charAt(j) == '*' && line.charAt(j + 1) == '/') {
-                        blockComment = false;
-                        j++;
-                    }
-                }
-            }
-
-            if (sb.length() > 0 && !blockComment) {
-                ans.add(sb.toString());
-                sb = new StringBuilder();
-            }
+  public List<String> removeComments(String[] source) {
+    StringBuilder sb = new StringBuilder();
+    List<String> list = new ArrayList<>();
+    boolean blockComment = false;
+    for (String word : source) {
+      for (int i = 0; i < word.length(); i++) {
+        if (!blockComment) {
+          if ((i + 1) < word.length() && word.charAt(i) == '/' && word.charAt(i + 1) == '/') {
+            break;
+          }
+          else if ((i + 1) < word.length() && word.charAt(i) == '/' && word.charAt(i + 1) == '*') {
+            blockComment = true;
+            i++;
+          }
+          else {
+            sb.append(word.charAt(i));
+          }
         }
-
-        return ans;
+        else {
+          if ((i + 1) < word.length() && word.charAt(i) == '*' && word.charAt(i + 1) == '/') {
+            blockComment = false;
+            i++;
+          }
+        }
+      }
+      if (!blockComment && sb.length() > 0) {
+        list.add(sb.toString());
+        sb.setLength(0);
+      }
     }
+    return list;
+  }
 }

From 5d71e4bf6cac66c960d0a6a69e8d7ba26209f5cb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 2 Jul 2020 17:41:31 -0500
Subject: [PATCH 0209/2175] Added 1 solution & modified 2 solutions

---
 .../Second Minimum Node in a binary tree.java | 56 ++++++++---------
 Medium/Design a File Sharing System.java      | 63 +++++++++++++++++++
 Medium/Find Bottom Left Tree Value.java       | 37 ++++++-----
 3 files changed, 113 insertions(+), 43 deletions(-)
 create mode 100644 Medium/Design a File Sharing System.java

diff --git a/Easy/Second Minimum Node in a binary tree.java b/Easy/Second Minimum Node in a binary tree.java
index fdcf16fc..2a3434b1 100644
--- a/Easy/Second Minimum Node in a binary tree.java	
+++ b/Easy/Second Minimum Node in a binary tree.java	
@@ -4,35 +4,35 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
-class Solution {
-    public int findSecondMinimumValue(TreeNode root) {
-        if (root == null) {
-            return -1;
-        }
-        if (root.left == null && root.right == null) {
-            return -1;
-        }
-
-        int left = root.left.val;
-        int right = root.right.val;
-
-        // if value same as root value, need to find the next candidate
-        if (root.left.val == root.val) {
-            left = findSecondMinimumValue(root.left);
-        }
-        if (root.right.val == root.val) {
-            right = findSecondMinimumValue(root.right);
-        }
-
-        if (left != -1 && right != -1) {
-            return Math.min(left, right);
-        } else if (left != -1) {
-            return left;
-        } else {
-            return right;
-        }
+class Solution {  
+  Integer minimum;
+  long secondMinimum;
+  public int findSecondMinimumValue(TreeNode root) {
+    minimum = root.val;
+    secondMinimum = Long.MAX_VALUE;
+    helper(root);
+    return secondMinimum == Long.MAX_VALUE ? -1 : (int) secondMinimum;
+  }
+  
+  private void helper(TreeNode root) {
+    if (root == null) {
+      return;
     }
+    if (minimum < root.val && root.val < secondMinimum) {
+      secondMinimum = root.val;
+    }
+    else if (root.val == minimum) {
+      helper(root.left);
+      helper(root.right);
+    }
+  }
 }
diff --git a/Medium/Design a File Sharing System.java b/Medium/Design a File Sharing System.java
new file mode 100644
index 00000000..2f6c3de7
--- /dev/null
+++ b/Medium/Design a File Sharing System.java	
@@ -0,0 +1,63 @@
+class FileSharing {
+  Map<Integer, Set<Integer>> chunkToUserMap;
+  Map<Integer, Set<Integer>> userToChunkMap;
+  int id;
+  PriorityQueue<Integer> availableIds;
+  public FileSharing(int m) {
+    id = 1;
+    chunkToUserMap = new HashMap<>();
+    userToChunkMap = new HashMap<>();
+    for (int i = 1; i <= m; i++) {
+      chunkToUserMap.put(i, new HashSet<>());
+    }
+    availableIds = new PriorityQueue<>();
+  }
+
+  public int join(List<Integer> ownedChunks) {
+    int userId = getUserId();
+    userToChunkMap.put(userId, new HashSet<>(ownedChunks));
+    for (Integer chunk : ownedChunks) {
+      chunkToUserMap.get(chunk).add(userId);
+    }
+    return userId;
+  }
+  
+  private int getUserId() {
+    if (availableIds.isEmpty()) {
+      return id++;
+    }
+    return availableIds.poll();
+  }
+
+  public void leave(int userID) {
+    Set<Integer> chunksOwned = userToChunkMap.get(userID);
+    userToChunkMap.remove(userID);
+    for (Integer chunk : chunksOwned) {
+      chunkToUserMap.get(chunk).remove(userID);
+    }
+    availableIds.add(userID);
+  }
+
+  public List<Integer> request(int userID, int chunkID) {
+    Set<Integer> usersOwningChunk = chunkToUserMap.get(chunkID);
+    Iterator<Integer> iterator = usersOwningChunk.iterator();
+    List<Integer> users = new ArrayList<>();
+    while (iterator.hasNext()) {
+      users.add(iterator.next());
+    }
+    if (!usersOwningChunk.contains(userID) && usersOwningChunk.size() > 0) {
+      userToChunkMap.get(userID).add(chunkID);
+      chunkToUserMap.get(chunkID).add(userID);
+    }
+    Collections.sort(users);
+    return users;
+  }
+}
+
+/**
+ * Your FileSharing object will be instantiated and called as such:
+ * FileSharing obj = new FileSharing(m);
+ * int param_1 = obj.join(ownedChunks);
+ * obj.leave(userID);
+ * List<Integer> param_3 = obj.request(userID,chunkID);
+ */
diff --git a/Medium/Find Bottom Left Tree Value.java b/Medium/Find Bottom Left Tree Value.java
index 924cd09c..e4f55477 100644
--- a/Medium/Find Bottom Left Tree Value.java	
+++ b/Medium/Find Bottom Left Tree Value.java	
@@ -4,24 +4,31 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    int ans = 0;
-    int height = 0;
-    
-    public int findBottomLeftValue(TreeNode root) {
-        findBottomLeftValue(root, 1);
-        return ans;
+  public int findBottomLeftValue(TreeNode root) {
+    int[] ans = {0, 0};
+    helper(root, 1, ans);
+    return ans[1];
+  }
+  
+  private void helper(TreeNode root, int currLevel, int[] ans) {
+    if (root == null) {
+      return;
     }
-    
-    public void findBottomLeftValue(TreeNode root, int depth) {
-        if (height < depth) {
-            ans = root.val;
-            height = depth;
-        }
-        if (root.left!=null) findBottomLeftValue(root.left, depth+1);
-        if (root.right!=null) findBottomLeftValue(root.right, depth+1);
+    if (currLevel > ans[0]) {
+      ans[0] = currLevel;
+      ans[1] = root.val;
     }
+    helper(root.left, currLevel + 1, ans);
+    helper(root.right, currLevel + 1, ans);
+  }
 }

From 61aee715f6de7e60cf9e5ec1a14238e9e3fb7625 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 3 Jul 2020 20:05:07 -0500
Subject: [PATCH 0210/2175] Added 1 solution & modified 6 solutions

---
 Easy/Defanging an IP Address.java             | 18 ++---
 Easy/N-Repeated Element in Size 2N Array.java |  7 +-
 Easy/Subdomain Visit Count.java               | 15 ++---
 Medium/All Paths From Source to Target.java   | 67 ++++++-------------
 ...rray in Sets of K Consecutive Numbers.java | 26 ++++---
 Medium/Prison Cells After N Days.java         | 18 ++---
 ...t Array into Consecutive Subsequences.java | 28 ++++++++
 7 files changed, 85 insertions(+), 94 deletions(-)
 create mode 100644 Medium/Split Array into Consecutive Subsequences.java

diff --git a/Easy/Defanging an IP Address.java b/Easy/Defanging an IP Address.java
index 06737d78..7f9b1525 100644
--- a/Easy/Defanging an IP Address.java	
+++ b/Easy/Defanging an IP Address.java	
@@ -1,15 +1,9 @@
 class Solution {
-    public String defangIPaddr(String address) {
-        StringBuilder sb = new StringBuilder();
-        for (char c : address.toCharArray()) {
-            if (c == '.') {
-                sb.append("[.]");
-            }
-            else {
-                sb.append(c);
-            }
-        }
-        
-        return sb.toString();
+  public String defangIPaddr(String address) {
+    StringBuilder sb = new StringBuilder();
+    for (char c : address.toCharArray()) {
+      sb.append(c == '.' ? "[.]" : c);
     }
+    return sb.toString();
+  }
 }
diff --git a/Easy/N-Repeated Element in Size 2N Array.java b/Easy/N-Repeated Element in Size 2N Array.java
index 890bf336..07a2ddcc 100644
--- a/Easy/N-Repeated Element in Size 2N Array.java	
+++ b/Easy/N-Repeated Element in Size 2N Array.java	
@@ -1,12 +1,11 @@
 class Solution {
   public int repeatedNTimes(int[] A) {
-    Map<Integer, Integer> map = new HashMap<>();
-    int n = A.length / 2;
+    int[] arr = new int[10001];
     for (int num : A) {
-      map.put(num, map.getOrDefault(num, 0) + 1);
-      if (map.get(num) == n) {
+      if (arr[num] == 1) {
         return num;
       }
+      arr[num]++;
     }
     return -1;
   }
diff --git a/Easy/Subdomain Visit Count.java b/Easy/Subdomain Visit Count.java
index c6eb65a0..5c99417d 100644
--- a/Easy/Subdomain Visit Count.java	
+++ b/Easy/Subdomain Visit Count.java	
@@ -1,16 +1,15 @@
 class Solution {
   public List<String> subdomainVisits(String[] cpdomains) {
     Map<String, Integer> map = new HashMap<>();
-    for(String domain : cpdomains) {
-      int count = Integer.parseInt(domain.split("\\s+")[0]);
-      String[] subDomains = domain.split("\\s+")[1].split("\\.");
+    for (String domain : cpdomains) {
+      String[] strs = domain.split("\\s+");
+      int count = Integer.parseInt(strs[0]);
+      String[] lowerDomains = strs[1].split("\\.");
       StringBuilder sb = new StringBuilder();
-      for (int i = subDomains.length - 1; i >= 0; i--) {
-        if (sb.length() != 0) {
-          sb.insert(0, ".");
-        }
-        sb.insert(0, subDomains[i]);
+      for (int i = lowerDomains.length - 1; i >= 0; i--) {
+        sb.insert(0, lowerDomains[i]);
         map.put(sb.toString(), map.getOrDefault(sb.toString(), 0) + count);
+        sb.insert(0, '.');
       }
     }
     List<String> list = new ArrayList<>();
diff --git a/Medium/All Paths From Source to Target.java b/Medium/All Paths From Source to Target.java
index d5ae70f2..e6fa3515 100644
--- a/Medium/All Paths From Source to Target.java	
+++ b/Medium/All Paths From Source to Target.java	
@@ -1,51 +1,24 @@
 class Solution {
-    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
-        int[][] newPath = getPath(graph);
-
-        int start = 0;
-        int destination = newPath.length-1;
-
-        List<List<Integer>> ans = printPossiblePaths(newPath, start, destination);
-        
-        return ans;
+  public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
+    List<List<Integer>> list = new ArrayList<>();
+    int target = graph.length - 1;
+    List<Integer> temp = new ArrayList<>();
+    temp.add(0);
+    helper(list, temp, 0, graph, target);
+    return list;
+  }
+  
+  private void helper(List<List<Integer>> list, List<Integer> temp, int curr, int[][] graph, int target) {
+    if (curr == target) {
+      list.add(new ArrayList<>(temp));
     }
-    
-    private static int[][] getPath(int[][] graph) {
-        int[][] path = new int[graph.length][graph.length];
-
-        for (int i=0; i<graph.length; i++) {
-            for (int j=0; j<graph[i].length; j++) {
-                path[i][graph[i][j]] = 1;
-            }
-        }
-
-        return path;
-    }
-    
-    public List<List<Integer>> printPossiblePaths(int[][] paths, int start, int destination) {
-        List<List<Integer>> ans = new ArrayList<>();
-        printPossiblePathsHelper(paths, start, destination, new StringBuilder().append(start).append("-"), ans);
-
-        return ans;
-    }
-
-    private void printPossiblePathsHelper(int[][] paths, int start, int destination, StringBuilder sb, List<List<Integer>> ans) {
-        int[] possiblePaths = paths[start];
-        if (start == destination) {
-            List<Integer> list = Arrays.
-                                    stream(sb.toString().split("-")).
-                                    mapToInt(Integer::parseInt).
-                                    boxed().
-                                    collect(Collectors.toList());
-            
-            ans.add(list);
-            return;
-        }
-
-        for (int i=0; i<possiblePaths.length; i++) {
-            if (possiblePaths[i] == 1 && sb.indexOf(String.valueOf(i)) == -1) {
-                printPossiblePathsHelper(paths, i, destination, new StringBuilder().append(sb.toString()).append(i).append("-"), ans);
-            }
-        }
+    else {
+      int[] connections = graph[curr];
+      for (int connection : connections) {
+        temp.add(connection);
+        helper(list, temp, connection, graph, target);
+        temp.remove(temp.size() - 1);
+      }
     }
+  }
 }
diff --git a/Medium/Divide Array in Sets of K Consecutive Numbers.java b/Medium/Divide Array in Sets of K Consecutive Numbers.java
index 31edb48b..1ec341d6 100644
--- a/Medium/Divide Array in Sets of K Consecutive Numbers.java	
+++ b/Medium/Divide Array in Sets of K Consecutive Numbers.java	
@@ -1,32 +1,30 @@
 class Solution {
   public boolean isPossibleDivide(int[] nums, int k) {
-    if (nums.length % k != 0) {
+    int n = nums.length;
+    if (k == 0 || n < k || n % k != 0) {
       return false;
     }
-    int n = nums.length;
-    int numOfGroups = n / k;
-    Map<Integer, Integer> map = new HashMap<>();
     PriorityQueue<Integer> pq = new PriorityQueue<>();
+    Map<Integer, Integer> map = new HashMap<>();
     for (int num : nums) {
       map.put(num, map.getOrDefault(num, 0) + 1);
     }
     pq.addAll(map.keySet());
     while (!pq.isEmpty()) {
       int polled = pq.poll();
-      if (map.get(polled) == 0) {
-        continue;
-      }
       int times = map.get(polled);
-      while (times-- > 0) {
-        for (int i = 0; i < k; i++) {
-          if (!map.containsKey(polled + i) || map.get(polled + i) == 0) {
-            return false;
+      if (times != 0) {
+        while (times-- > 0) {
+          for (int i = 0; i < k; i++) {
+            if (!map.containsKey(polled + i) || map.get(polled + i) == 0) {
+              return false;
+            }
+            map.put(polled + i, map.get(polled + i) - 1);
           }
-          map.put(polled + i, map.get(polled + i) - 1);
+          n -= k;
         }
-        n -= k;
       }
     }
-    return n == 0;
+    return true;
   }
 }
diff --git a/Medium/Prison Cells After N Days.java b/Medium/Prison Cells After N Days.java
index ca9a58f7..6010b774 100644
--- a/Medium/Prison Cells After N Days.java	
+++ b/Medium/Prison Cells After N Days.java	
@@ -2,15 +2,15 @@ class Solution {
   public int[] prisonAfterNDays(int[] cells, int N) {
     Map<String, Integer> seen = new HashMap<>();
     while (N > 0) {
-        int[] cells2 = new int[8];
-        seen.put(Arrays.toString(cells), N--);
-        for (int i = 1; i < 7; ++i) {
-            cells2[i] = cells[i - 1] == cells[i + 1] ? 1 : 0;
-        }
-        cells = cells2;
-        if (seen.containsKey(Arrays.toString(cells))) {
-            N %= seen.get(Arrays.toString(cells)) - N;
-        }
+      int[] cells2 = new int[8];
+      seen.put(Arrays.toString(cells), N--);
+      for (int i = 1; i < 7; ++i) {
+        cells2[i] = cells[i - 1] == cells[i + 1] ? 1 : 0;
+      }
+      cells = cells2;
+      if (seen.containsKey(Arrays.toString(cells))) {
+        N %= seen.get(Arrays.toString(cells)) - N;
+      }
     }
     return cells;
   }
diff --git a/Medium/Split Array into Consecutive Subsequences.java b/Medium/Split Array into Consecutive Subsequences.java
new file mode 100644
index 00000000..f31de956
--- /dev/null
+++ b/Medium/Split Array into Consecutive Subsequences.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public boolean isPossible(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    Map<Integer, Integer> appendMap = new HashMap<>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    for (int i : nums) {
+      if (map.get(i) == 0) {
+        continue;
+      }
+      else if (appendMap.getOrDefault(i, 0) > 0) {
+        appendMap.put(i, appendMap.get(i) - 1);
+        appendMap.put(i + 1, appendMap.getOrDefault(i + 1, 0) + 1);
+      }
+      else if (map.getOrDefault(i + 1, 0) > 0 && map.getOrDefault(i + 2, 0) > 0) {
+        map.put(i + 1, map.get(i + 1) - 1);
+        map.put(i + 2, map.get(i + 2) - 1);
+        appendMap.put(i + 3, appendMap.getOrDefault(i + 3, 0) + 1);
+      }
+      else {
+        return false;
+      }
+      map.put(i, map.get(i) - 1);
+    }
+    return true;
+  }
+}

From 1a50275c25e8ba9a81eb7320751c09019529ed9a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 4 Jul 2020 10:02:06 -0500
Subject: [PATCH 0211/2175] Modified 2 solutions

---
 Easy/Ugly Number.java      | 23 +++++++++++++++
 Easy/ugly_number.java      | 24 ----------------
 Medium/Ugly Number II.java | 59 +++++++++++++++++---------------------
 3 files changed, 50 insertions(+), 56 deletions(-)
 create mode 100644 Easy/Ugly Number.java
 delete mode 100644 Easy/ugly_number.java

diff --git a/Easy/Ugly Number.java b/Easy/Ugly Number.java
new file mode 100644
index 00000000..e8d27ea0
--- /dev/null
+++ b/Easy/Ugly Number.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public boolean isUgly(int num) {
+    if (num <= 0) {
+      return false;
+    }
+    long lNum = (long) num;
+    while (lNum > 1) {
+      if (lNum % 2 == 0) {
+        lNum /= 2;
+      }
+      else if (lNum % 3 == 0) {
+        lNum /= 3;
+      }
+      else if (lNum % 5 == 0) {
+        lNum /= 5;
+      }
+      else {
+        return false;
+      }
+    }
+    return true;
+  }
+}
diff --git a/Easy/ugly_number.java b/Easy/ugly_number.java
deleted file mode 100644
index e286ed9a..00000000
--- a/Easy/ugly_number.java
+++ /dev/null
@@ -1,24 +0,0 @@
-public class Solution {
-    public boolean isUgly(int num) {
-        if(num<=0)
-        {
-        	return false;
-        }
-        else
-        {
-        	while(num%2==0)
-        	{
-        		num/=2;
-        	}
-        	while(num%3==0)
-        	{
-        		num/=3;
-        	}
-        	while(num%5==0)
-        	{
-        		num/=5;
-        	}
-        	return num==1;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Medium/Ugly Number II.java b/Medium/Ugly Number II.java
index f7705d14..d9fe4082 100644
--- a/Medium/Ugly Number II.java	
+++ b/Medium/Ugly Number II.java	
@@ -1,35 +1,30 @@
 class Solution {
-    public static int nthUglyNumber(int n) {
-        int[] arr = new int[n];
-        arr[0] = 1;
-        int i2 = 0;
-        int i3 = 0;
-        int i5 = 0;
-
-        int mul2 = 2;
-        int mul3 = 3;
-        int mul5 = 5;
-
-        int ugly = 1;
-
-        for (int i=1; i<n; i++) {
-            ugly = Math.min(mul2, Math.min(mul3, mul5));
-            arr[i] = ugly;
-
-            if (ugly == mul2) {
-                i2++;
-                mul2 = arr[i2]*2;
-            }
-            if (ugly == mul3) {
-                i3++;
-                mul3 = arr[i3]*3;
-            }
-            if (ugly == mul5) {
-                i5++;
-                mul5 = arr[i5]*5;
-            }
-        }
-
-        return ugly;
+  public int nthUglyNumber(int n) {
+    int[] arr = new int[n];
+    arr[0] = 1;
+    int idx2 = 0;
+    int idx3 = 0;
+    int idx5 = 0;
+    int mul2 = 2;
+    int mul3 = 3;
+    int mul5 = 5;
+    int ugly = arr[0];
+    for (int i = 1; i < n; i++) {
+      ugly = Math.min(mul2, Math.min(mul3, mul5));
+      arr[i] = ugly;
+      if (ugly == mul2) {
+        idx2++;
+        mul2 = arr[idx2] * 2;
+      }
+      if (ugly == mul3) {
+        idx3++;
+        mul3 = arr[idx3] * 3;
+      }
+      if (ugly == mul5) {
+        idx5++;
+        mul5 = arr[idx5] * 5;
+      }
     }
+    return ugly;
+  }
 }

From d55f35726335c81ac70606660d0b329017617ba5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 4 Jul 2020 19:25:05 -0500
Subject: [PATCH 0212/2175] Added 1 solution & modified 5 solutions

---
 Easy/Remove Linked List Elements.java         | 35 ++++-----
 Medium/3Sum.java                              | 70 ++++++++----------
 .../Flatten Binary Tree to Linked List.java   | 51 ++++++-------
 ...Letter Combinations of a Phone Number.java | 71 ++++++++-----------
 Medium/Next Permutation.java                  | 64 ++++++++---------
 ...anies Is Not a Subset of Another List.java | 47 ++++++++++++
 6 files changed, 180 insertions(+), 158 deletions(-)
 create mode 100644 Medium/People Whose List of Favorite Companies Is Not a Subset of Another List.java

diff --git a/Easy/Remove Linked List Elements.java b/Easy/Remove Linked List Elements.java
index 5f4b5c21..9bc15504 100644
--- a/Easy/Remove Linked List Elements.java	
+++ b/Easy/Remove Linked List Elements.java	
@@ -3,23 +3,26 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode removeElements(ListNode head, int val) {
-        if (head == null) {
-            return null;
-        }
-        ListNode current = head;
-        while (current.next != null) {
-            if (current.next.val == val) {
-                current.next = current.next.next;
-            }
-            else {
-                current = current.next;
-            }
-        }
-        return head.val == val ? head.next : head;
+  public ListNode removeElements(ListNode head, int val) {
+    while (head != null && head.val == val) {
+      head = head.next;
     }
-}
\ No newline at end of file
+    ListNode newHead = head;
+    ListNode curr = newHead;
+    while (curr != null && curr.next != null) {
+      if (curr.next.val == val) {
+        curr.next = curr.next.next;
+      }
+      else {
+        curr = curr.next;
+      }
+    }
+    return newHead;
+  }
+}
diff --git a/Medium/3Sum.java b/Medium/3Sum.java
index e6bdbc7b..0bf94c28 100644
--- a/Medium/3Sum.java
+++ b/Medium/3Sum.java
@@ -1,45 +1,35 @@
 class Solution {
-    public List<List<Integer>> threeSum(int[] nums) {
-        Set<List<Integer>> set = new HashSet<>();
-        Arrays.sort(nums);
-        for (int i=0; i<nums.length; i++) {
-            for (int j=i+1; j<nums.length; j++) {
-                int target = -1 * (nums[i] + nums[j]);
-                
-                int idx = findBinary(nums, j+1, nums.length-1, target);
-                
-                if (idx != -1) {
-                    List<Integer> temp = new ArrayList<>();
-                    temp.add(nums[i]);
-                    temp.add(nums[j]);
-                    temp.add(nums[idx]);
-                    
-                    set.add(temp);
-                }
-            }
+  public List<List<Integer>> threeSum(int[] nums) {
+    Set<List<Integer>> set = new HashSet<>();
+    Arrays.sort(nums);
+    for (int i = 0; i < nums.length; i++) {
+      for (int j = i + 1; j < nums.length; j++) {
+        int idx = binarySearchHelper(nums, j + 1, nums.length - 1, -1 * (nums[i] + nums[j]));
+        if (idx != -1) {
+          List<Integer> temp = new ArrayList<>();
+          temp.add(nums[i]);
+          temp.add(nums[j]);
+          temp.add(nums[idx]);
+          set.add(temp);
         }
-        
-        List<List<Integer>> ans = new ArrayList<>(); 
-        ans.addAll(set);
-        
-        return ans;
+      }
     }
-    
-    private int findBinary(int[] nums, int start, int end, int target) {
-        while (start <= end) {
-            int mid = (start + end)/2;
-            
-            if(nums[mid] == target) {
-                return mid;
-            }
-            else if (nums[mid] > target) {
-                end = mid-1;
-            }
-            else {
-                start = mid + 1;
-            }
-        }
-        
-        return -1;
+    return new ArrayList<>(set);
+  }
+  
+  private int binarySearchHelper(int[] nums, int start, int end, int target) {
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (nums[mid] == target) {
+        return mid;
+      }
+      else if (nums[mid] > target) {
+        end = mid - 1;
+      }
+      else {
+        start = mid + 1;
+      }
     }
+    return -1;
+  }
 }
diff --git a/Medium/Flatten Binary Tree to Linked List.java b/Medium/Flatten Binary Tree to Linked List.java
index 2c2f5489..b3e79dac 100644
--- a/Medium/Flatten Binary Tree to Linked List.java	
+++ b/Medium/Flatten Binary Tree to Linked List.java	
@@ -4,33 +4,34 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public void flatten(TreeNode root) {
-        if (root == null) {
-            return;
-        }
-        
-        // Store left and right of root
-        TreeNode left = root.left;
-        TreeNode right = root.right;
-        
-        root.left = null;
-        
-        flatten(left);
-        flatten(right);
-        
-        // Make root.right to null and traverse to last node of right
-        root.right = left;
-        TreeNode curr = root;
-        
-        while (curr.right != null) {
-            curr = curr.right;
-        }
-        
-        // Make last node's right equal to stored right
-        curr.right = right;
+  public void flatten(TreeNode root) {
+    if (root == null) {
+      return;
     }
+    Stack<TreeNode> stack = new Stack<>();
+    stack.push(root);
+    while (!stack.isEmpty()) {
+      TreeNode curr = stack.pop();
+      if (curr.right != null) {
+        stack.push(curr.right);
+      }
+      if (curr.left != null) {
+        stack.push(curr.left);
+      }
+      if (!stack.isEmpty()) {
+        curr.right = stack.peek();
+      }
+      curr.left = null;
+    }
+  }
 }
diff --git a/Medium/Letter Combinations of a Phone Number.java b/Medium/Letter Combinations of a Phone Number.java
index f3dc991a..81be5ec2 100644
--- a/Medium/Letter Combinations of a Phone Number.java	
+++ b/Medium/Letter Combinations of a Phone Number.java	
@@ -1,46 +1,35 @@
 class Solution {
-    public List<String> combinations;
-    public Map<Character, String> map;
-
-    public List<String> letterCombinations(String number) {
-        if (number.length() == 0) {
-            return new ArrayList<>();
-        }
-        
-        combinations = new ArrayList<>();
-        map = new HashMap<>();
-        char[] chars = {'1', '2', '3', '4', '5', '6', '7', '8', '9'};
-        String[] values = {"*", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
-
-        for (int i=0; i<chars.length; i++) {
-            map.put(chars[i], values[i]);
-        }
-
-        StringBuilder sb = new StringBuilder();
-        helper(number, sb, 0);
-
-        return combinations;
+  public List<String> letterCombinations(String digits) {
+    if (digits.length() == 0) {
+      return new ArrayList<>();
     }
-
-    private void helper(String num, StringBuilder sb, int start) {
-        if (sb.length() == num.length()) {
-            combinations.add(new StringBuilder(sb.toString()).toString());
-            return;
-        }
-
-        for (int i=start; i<num.length(); i++) {
-            String val = map.get(num.charAt(i));
-
-            for (char c : val.toCharArray()) {
-                // Choose
-                sb.append(c);
-
-                // Explore
-                helper(num, sb, i+1);
-
-                // Un-choose
-                sb.deleteCharAt(sb.length() - 1);
-            }
+    String[] strs = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+    Map<Integer, String> map = new HashMap<>();
+    for (int i = 2; i <= 9; i++) {
+      map.put(i, strs[i - 2]);
+    }
+    List<String> list = new ArrayList<>();
+    helper(digits, 0, digits.length(), new StringBuilder(), map, list);
+    return list;
+  }
+  
+  private void helper(
+    String digits, int idx, int n, StringBuilder sb, Map<Integer, String> map, List<String> list
+  ) {
+    if (idx == n) {
+      if (sb.length() == n) {
+        list.add(sb.toString());
+      }
+    }
+    else {
+      for (int i = idx; i < n; i++) {
+        int digit = Character.getNumericValue(digits.charAt(i));
+        for (char c : map.get(digit).toCharArray()) {
+          sb.append(c);
+          helper(digits, i + 1, n, sb, map, list);
+          sb.deleteCharAt(sb.length() - 1);
         }
+      }
     }
+  }
 }
diff --git a/Medium/Next Permutation.java b/Medium/Next Permutation.java
index f9c7c940..a29876cb 100644
--- a/Medium/Next Permutation.java	
+++ b/Medium/Next Permutation.java	
@@ -1,40 +1,32 @@
 class Solution {
-    public void nextPermutation(int[] nums) {
-        // Keep moving right to left until a down slope is found
-        boolean noChange = true;
-        int right = nums.length - 1;
-        int start = right;
-        while (start >= 1) {
-            // When found, swap the number with rightmost digit which is greater 
-            // than the digit on the down slope
-            if (nums[start] > nums[start - 1]) {
-                int idx = right;
-                while (nums[idx] <= nums[start - 1]) {
-                    idx--;
-                }
-                
-                int temp = nums[start - 1];
-                nums[start - 1] = nums[idx];
-                nums[idx] = temp;
-                noChange = false;
-                break;
-            }
-            
-            start--;
-        }
-        
-        if (noChange) {
-            Arrays.sort(nums);
-            return;
-        }
-        
-        // Reverse everything to the right of down slope
-        while (start < right) {
-            int temp = nums[start];
-            nums[start] = nums[right];
-            nums[right] = temp;
-            start++;
-            right--;
+  public void nextPermutation(int[] nums) {
+    boolean flag = true;
+    int right = nums.length - 1;
+    int start = right;
+    while (start >= 1) {
+      if (nums[start] > nums[start - 1]) {
+        int idx = right;
+        while (nums[idx] <= nums[start - 1]) {
+          idx--;
         }
+        int temp = nums[start - 1];
+        nums[start - 1] = nums[idx];
+        nums[idx] = temp;
+        flag = false;
+        break;
+      }
+      start--;
+    }
+    if (flag) {
+      Arrays.sort(nums);
+      return;
+    }
+    while (start < right) {
+      int temp = nums[start];
+      nums[start] = nums[right];
+      nums[right] = temp;
+      start++;
+      right--;
     }
+  }
 }
diff --git a/Medium/People Whose List of Favorite Companies Is Not a Subset of Another List.java b/Medium/People Whose List of Favorite Companies Is Not a Subset of Another List.java
new file mode 100644
index 00000000..bb29bc53
--- /dev/null
+++ b/Medium/People Whose List of Favorite Companies Is Not a Subset of Another List.java	
@@ -0,0 +1,47 @@
+class Solution {
+  public List<Integer> peopleIndexes(List<List<String>> favoriteCompanies) {
+    Map<String, Integer> map = new HashMap<>();
+    List<List<Integer>> hashedList = new ArrayList<>();
+    int count = 1;
+    for (List<String> companies : favoriteCompanies) {
+      List<Integer> temp = new ArrayList<>();
+      for (String company : companies) {
+        if (!map.containsKey(company)) {
+          map.put(company, count++);
+        }
+        temp.add(map.get(company));
+      }
+      Collections.sort(temp);
+      hashedList.add(temp);
+    }
+    List<Integer> foundList = new ArrayList<>();
+    int n = hashedList.size();
+    for (int i = 0; i < n; i++) {
+      boolean found = false;
+      for (int j = 0; j < n && !found; j++) {
+        if (i != j) {
+          List<Integer> curr = hashedList.get(j);
+          List<Integer> target = hashedList.get(i);
+          int idxCurr = 0;
+          int idxTarget = 0;
+          int sizeCurr = curr.size();
+          int sizeTarget = target.size();
+          while (idxCurr < sizeCurr && idxTarget < sizeTarget) {
+            if (curr.get(idxCurr) == target.get(idxTarget)) {
+              idxTarget++;
+            }
+            idxCurr++;
+          }
+          if (idxTarget == sizeTarget) {
+            found = true;
+            break;
+          }
+        }
+      }
+      if (!found) {
+        foundList.add(i);
+      }
+    }
+    return foundList;
+  }
+}

From 2519784816bf1badbb79f87704649b2af89e40d0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 5 Jul 2020 12:11:04 -0500
Subject: [PATCH 0213/2175] Added 2 solutions & modified 3 solutions

---
 ... Arithmetic Progression From Sequence.java | 12 ++++
 Easy/Hamming Distance.java                    | 55 ++++---------------
 ... With Total Durations Divisible by 60.java | 23 ++++----
 Easy/To Lower Case.java                       | 23 ++++----
 ...t Before All Ants Fall Out of a Plank.java | 12 ++++
 5 files changed, 57 insertions(+), 68 deletions(-)
 create mode 100644 Easy/Can Make Arithmetic Progression From Sequence.java
 create mode 100644 Medium/Last Moment Before All Ants Fall Out of a Plank.java

diff --git a/Easy/Can Make Arithmetic Progression From Sequence.java b/Easy/Can Make Arithmetic Progression From Sequence.java
new file mode 100644
index 00000000..edc5b0db
--- /dev/null
+++ b/Easy/Can Make Arithmetic Progression From Sequence.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public boolean canMakeArithmeticProgression(int[] arr) {
+    Arrays.sort(arr);
+    int diff = arr[1] - arr[0];
+    for (int i = 2; i < arr.length; i++) {
+      if (arr[i] - arr[i - 1] != diff) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
diff --git a/Easy/Hamming Distance.java b/Easy/Hamming Distance.java
index d6e0a284..ce060325 100644
--- a/Easy/Hamming Distance.java	
+++ b/Easy/Hamming Distance.java	
@@ -1,46 +1,13 @@
 class Solution {
-    public int hammingDistance(int x, int y) {
-        return findCount(x,y);
+  public int hammingDistance(int x, int y) {
+    int xor = x ^ y;
+    int count = 0;
+    while (xor != 0) {
+      if (xor % 2 == 1) {
+        count++;
+      }
+      xor = xor >> 1;
     }
-    public int findCount(int x, int y) {
-        StringBuilder sbX = new StringBuilder("");
-        StringBuilder sbY = new StringBuilder("");
-        
-        while (x>0) {
-            sbX.append(String.valueOf(x%2));
-            x /= 2;
-        }
-        
-        while (y>0) {
-            sbY.append(String.valueOf(y%2));
-            y /= 2;
-        }
-        
-        String binX = sbX.reverse().toString();
-        String binY = sbY.reverse().toString();
-    
-        if (binX.length() > binY.length()) {
-            int d = binX.length() - binY.length();
-            while (d>0) {
-                binY = "0" + binY;
-                d--;
-            }
-        }
-        else if (binX.length() < binY.length()) {
-            int d = binY.length() - binX.length();
-            while (d>0) {
-                binX = "0" + binX;
-                d--;
-            }
-        }
-        
-        int count = 0;
-        for (int i=0;i<binX.length();i++) {
-            if (binX.charAt(i) != binY.charAt(i)) {
-                count++;
-            }
-        }
-
-        return count;
-    }
-}
\ No newline at end of file
+    return count;
+  }
+}
diff --git a/Easy/Pairs of Songs With Total Durations Divisible by 60.java b/Easy/Pairs of Songs With Total Durations Divisible by 60.java
index 82877cbf..5bf90390 100644
--- a/Easy/Pairs of Songs With Total Durations Divisible by 60.java	
+++ b/Easy/Pairs of Songs With Total Durations Divisible by 60.java	
@@ -1,16 +1,13 @@
 class Solution {
-    public int numPairsDivisibleBy60(int[] time) {
-        int count = 0;
-        Map<Integer, Integer> map = new HashMap<>();
-        
-        for (int i = 0; i < time.length; i++) {
-            if (map.containsKey((60 - time[i] % 60) % 60)) {
-                count += map.get((60 - time[i] % 60) % 60);
-            }
-            
-            map.put(time[i] % 60, map.getOrDefault(time[i] % 60, 0) + 1);
-        }
-        
-        return count;
+  public int numPairsDivisibleBy60(int[] time) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int count = 0;
+    for (int t : time) {
+      if (map.containsKey(((60 - t % 60)) % 60)) {
+        count += map.get((60 - t % 60) % 60);
+      }
+      map.put(t % 60, map.getOrDefault(t % 60, 0) + 1);
     }
+    return count;
+  }
 }
diff --git a/Easy/To Lower Case.java b/Easy/To Lower Case.java
index a65387c9..623cb4d6 100644
--- a/Easy/To Lower Case.java	
+++ b/Easy/To Lower Case.java	
@@ -1,14 +1,15 @@
 class Solution {
-    public String toLowerCase(String str) {
-        char[] chars = str.toCharArray();
-        for (int i=0; i<chars.length; i++) {
-            int ascii = (int) chars[i];
-            if (ascii >= 65 && ascii <= 90) {
-                ascii = 97 + (ascii - 65);
-                chars[i] = (char) ascii;
-            }
-        }
-        
-        return String.valueOf(chars);
+  public String toLowerCase(String str) {
+    StringBuilder sb = new StringBuilder();
+    for (char c : str.toCharArray()) {
+      int ascii = (int) c;
+      if (c >= 65 && c <= 90) {
+        sb.append((char) (c - 65 + 97));
+      }
+      else {
+        sb.append(c);
+      }
     }
+    return sb.toString();
+  }
 }
diff --git a/Medium/Last Moment Before All Ants Fall Out of a Plank.java b/Medium/Last Moment Before All Ants Fall Out of a Plank.java
new file mode 100644
index 00000000..45e59801
--- /dev/null
+++ b/Medium/Last Moment Before All Ants Fall Out of a Plank.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int getLastMoment(int n, int[] left, int[] right) {
+    int res = 0;
+    for (int ant : left) {
+      res = Math.max(res, ant);
+    }
+    for (int ant : right) {
+      res = Math.max(res, n - ant);
+    }
+    return res;
+  }
+}

From ad530bdebda249c0eed02ff43ed1cab2dbce2362 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 5 Jul 2020 19:24:12 -0500
Subject: [PATCH 0214/2175] Modified 2 solutions

---
 Easy/Intersection of Two Arrays.java    | 20 +++++++++++++
 Easy/Intersection of two arrays II.java | 38 +++++++++++--------------
 Easy/intersection_of_two_arrays.java    | 28 ------------------
 3 files changed, 37 insertions(+), 49 deletions(-)
 create mode 100644 Easy/Intersection of Two Arrays.java
 delete mode 100644 Easy/intersection_of_two_arrays.java

diff --git a/Easy/Intersection of Two Arrays.java b/Easy/Intersection of Two Arrays.java
new file mode 100644
index 00000000..b17c8dea
--- /dev/null
+++ b/Easy/Intersection of Two Arrays.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int[] intersection(int[] nums1, int[] nums2) {
+    Set<Integer> set = new HashSet<>();
+    for (int num : nums1) {
+      set.add(num);
+    }
+    Set<Integer> match = new HashSet<>();
+    for (int num : nums2) {
+      if (set.contains(num)) {
+        match.add(num);
+      }
+    }
+    int[] ans = new int[match.size()];
+    Iterator<Integer> iter = match.iterator();
+    for (int i = 0; i < ans.length; i++) {
+      ans[i] = iter.next();
+    }
+    return ans;
+  }
+}
diff --git a/Easy/Intersection of two arrays II.java b/Easy/Intersection of two arrays II.java
index 17c4fe8d..69407386 100644
--- a/Easy/Intersection of two arrays II.java	
+++ b/Easy/Intersection of two arrays II.java	
@@ -1,24 +1,20 @@
 class Solution {
-    public int[] intersect(int[] nums1, int[] nums2) {
-        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
-        ArrayList<Integer> result = new ArrayList<Integer>();
-        for(int i = 0; i < nums1.length; i++) {
-            if(map.containsKey(nums1[i])) map.put(nums1[i], map.get(nums1[i])+1);
-            else map.put(nums1[i], 1);
-        }
-        
-        for(int i = 0; i < nums2.length; i++) {
-            if(map.containsKey(nums2[i]) && map.get(nums2[i]) > 0) {
-                result.add(nums2[i]);
-                map.put(nums2[i], map.get(nums2[i])-1);
-            }
-        }
-        
-        int[] r = new int[result.size()];
-        for(int i = 0; i < result.size(); i++) {
-            r[i] = result.get(i);
-        }
-    
-       return r;
+  public int[] intersect(int[] nums1, int[] nums2) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums1) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
     }
+    List<Integer> list = new ArrayList<>();
+    for (int num : nums2) {
+      if (map.getOrDefault(num, 0) > 0) {
+        list.add(num);
+        map.put(num, map.get(num) - 1);
+      } 
+    }
+    int[] ans = new int[list.size()];
+    for (int i = 0; i < list.size(); i++) {
+      ans[i] = list.get(i);
+    }
+    return ans;
+  }
 }
diff --git a/Easy/intersection_of_two_arrays.java b/Easy/intersection_of_two_arrays.java
deleted file mode 100644
index dd24cb15..00000000
--- a/Easy/intersection_of_two_arrays.java
+++ /dev/null
@@ -1,28 +0,0 @@
-public class Solution {
-    public int[] intersection(int[] nums1, int[] nums2) {
-        ArrayList<Integer> al=new ArrayList<Integer>();
-        for (int i=0;i<nums1.length;i++) {
-            if(findIndex(nums2, nums1[i]) != -1 && al.contains(nums1[i]) == false) {
-                al.add(nums1[i]);
-            }
-        }
-        return convertIntegers(al);
-    }
-    
-    public static int findIndex(int[] nums, int elem) {
-        for (int i=0;i<nums.length;i++) {
-            if (nums[i] == elem) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    
-    public static int[] convertIntegers(List<Integer> integers) {
-        int[] ret = new int[integers.size()];
-        for (int i=0; i < ret.length; i++) {
-            ret[i] = integers.get(i).intValue();
-        }
-        return ret;
-    }
-}
\ No newline at end of file

From c53fdf5e294df89ab0d4b9434ddcab18f40afcab Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 6 Jul 2020 10:15:12 -0500
Subject: [PATCH 0215/2175] Added 1 solution & modified 3 solutions

---
 Easy/Plus One.java                            | 49 ++++-------
 Medium/Merge Intervals.java                   | 87 ++++++++-----------
 ...st Subtree with all the Deepest Nodes.java | 54 ++++++++++++
 Medium/Ternary Expression Parser.java         | 47 +++++-----
 4 files changed, 129 insertions(+), 108 deletions(-)
 create mode 100644 Medium/Smallest Subtree with all the Deepest Nodes.java

diff --git a/Easy/Plus One.java b/Easy/Plus One.java
index 75f6ff58..adc57cdd 100644
--- a/Easy/Plus One.java	
+++ b/Easy/Plus One.java	
@@ -1,35 +1,20 @@
 class Solution {
-    public int[] plusOne(int[] digits) {
-        
-        int carry = 1;
-        List<Integer> ans = new ArrayList<>();
-        
-        for (int i=digits.length-1;i>=0;i--) {
-            if (digits[i] == 9 && carry == 1) {
-                ans.add(0);
-                carry  = 1;
-            }
-            else if (carry == 1) {
-                ans.add(digits[i]+carry);
-                carry = 0;
-            }
-            else {
-                ans.add(digits[i]+carry);
-            }
-        }
-        
-        if (carry!=0) {
-            ans.add(carry);
-        }
-        
-        Collections.reverse(ans);
-        
-        int [] a = new int[ans.size()];
-        
-        for (int k=0; k<ans.size();k++) {
-            a[k] = ans.get(k);
-        }
-        
-        return a;
+  public int[] plusOne(int[] digits) {
+    int carry = 1;
+    int n = digits.length;
+    for (int i = n - 1; i >= 0; i--) {
+      int temp = digits[i] + carry;
+      if (temp <= 9) {
+        digits[i] = temp;
+        return digits;
+      }
+      digits[i] = temp % 10;
     }
+    int[] newDigits = new int[n + 1];
+    newDigits[0] = 1;
+    for (int i = 1; i < n + 1; i++) {
+      newDigits[i] = digits[i - 1];
+    }
+    return newDigits;
+  }   
 }
diff --git a/Medium/Merge Intervals.java b/Medium/Merge Intervals.java
index fcef1675..c770e419 100644
--- a/Medium/Merge Intervals.java	
+++ b/Medium/Merge Intervals.java	
@@ -1,55 +1,44 @@
-/**
- * Definition for an interval.
- * public class Interval {
- *     int start;
- *     int end;
- *     Interval() { start = 0; end = 0; }
- *     Interval(int s, int e) { start = s; end = e; }
- * }
- */
 class Solution {
-    public static List<Interval> merge(List<Interval> intervals) {
-
-        if (intervals.size() == 1) {
-            return intervals;
+  public int[][] merge(int[][] intervals) {
+    Arrays.sort(intervals, new Comparator<int[]>(){
+      public int compare(int[] o1, int[] o2) {
+        int c = o1[0] - o2[0];
+        if (c != 0) {
+          return c;
         }
-
-        List<Interval> ans = new ArrayList<>();
-        if (intervals.size() == 0) {
-            return ans;
+        return o1[1] - o2[1];
+      }
+    });
+    List<int[]> intervalList = new ArrayList<>();
+    int end = 0;
+    int n = intervals.length;
+    int currStart = -1;
+    int currEnd = -1;
+    while (end < n) {
+      if (currStart == -1 && currEnd == -1) {
+        currStart = intervals[end][0];
+        currEnd = intervals[end][1];
+        end++;
+      }
+      if (end < n) {
+        if (currEnd >= intervals[end][0]) {
+          currEnd = Math.max(intervals[end][1], currEnd);
+          end++;
         }
-
-        Collections.sort(intervals, new Comparator<Interval>() {
-            @Override
-            public int compare(Interval o1, Interval o2) {
-                return o1.start - o2.start;
-            }
-        });
-
-        int i = 0;
-        Interval prevInterval = null;
-
-        List<Interval> temp = new ArrayList<>(intervals);
-
-        for (Interval interval : temp) {
-            if (i == 0) {
-                prevInterval = interval;
-                i++;
-                continue;
-            }
-
-            if (interval.start <= prevInterval.end) {
-                if (interval.end >= prevInterval.end) {
-                    prevInterval.end = interval.end;
-                }
-
-                intervals.remove(interval);
-            }
-            else {
-                prevInterval = interval;
-            }
+        else {
+          intervalList.add(new int[]{currStart, currEnd});
+          currStart = -1;
+          currEnd = -1;
         }
-
-        return intervals;
+      }
+      if (end == n && currStart != -1 && currEnd != -1) {
+        intervalList.add(new int[]{currStart, currEnd});
+      }
     }
+    int[][] ans = new int[intervalList.size()][2];
+    for (int i = 0; i < intervalList.size(); i++) {
+      ans[i] = intervalList.get(i);
+    }
+    return ans;
+  }
 }
diff --git a/Medium/Smallest Subtree with all the Deepest Nodes.java b/Medium/Smallest Subtree with all the Deepest Nodes.java
new file mode 100644
index 00000000..3999f22e
--- /dev/null
+++ b/Medium/Smallest Subtree with all the Deepest Nodes.java	
@@ -0,0 +1,54 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  Map<TreeNode, Integer> map;
+  int maxDepth;
+  public TreeNode subtreeWithAllDeepest(TreeNode root) {
+    map = new HashMap<>();
+    maxDepth = -1;
+    map.put(null, -1);
+    dfs(root, null);
+    return helper(root);
+  }
+  
+  private void dfs(TreeNode root, TreeNode parent) {
+    if (root == null) {
+      return;
+    }
+    map.put(root, map.get(parent) + 1);
+    maxDepth = Math.max(maxDepth, map.get(root));
+    dfs(root.left, root);
+    dfs(root.right, root);
+  }
+  
+  private TreeNode helper(TreeNode root) {
+    if (root == null || map.get(root) == maxDepth) {
+      return root;
+    }
+    TreeNode left = helper(root.left);
+    TreeNode right = helper(root.right);
+    if (left != null && right != null) {
+      return root;
+    }
+    if (left != null) {
+      return left;
+    }
+    if (right != null) {
+      return right;
+    }
+    return null;
+  }
+}
diff --git a/Medium/Ternary Expression Parser.java b/Medium/Ternary Expression Parser.java
index 67b0118d..c0079881 100644
--- a/Medium/Ternary Expression Parser.java	
+++ b/Medium/Ternary Expression Parser.java	
@@ -1,30 +1,23 @@
 class Solution {
-    public String parseTernary(String expression) {
-        if (expression.length() <= 1) {
-            return expression;
-        }
-
-        int idx = expression.indexOf('?');
-        int count = 0;
-
-        while (idx < expression.length()) {
-            if (expression.charAt(idx) == '?') {
-                count++;
-            }
-            else if (expression.charAt(idx) == ':') {
-                count--;
-            }
-            else if (count == 0) {
-                break;
-            }
-
-            idx++;
-        }
-
-        String booleanCheck = expression.substring(0, expression.indexOf('?'));
-        String left = expression.substring(expression.indexOf('?') + 1, idx-1);
-        String right = expression.substring(idx);
-
-        return booleanCheck.equals("T") ? parseTernary(left) : parseTernary(right);
+  public String parseTernary(String expression) {
+    if (expression == null || expression.length() == 0) {
+      return "";
     }
+    Deque<Character> stack = new LinkedList<>();
+    int n = expression.length();
+    for (int i = n - 1; i >= 0; i--) {
+      char c = expression.charAt(i);
+      if (!stack.isEmpty() && stack.peek() == '?') {
+        stack.pop();  // Pop ?
+        char first = stack.pop();
+        stack.pop();  // Pop :
+        char second = stack.pop();
+        stack.push(c == 'T' ? first : second);
+      }
+      else {
+        stack.push(c);
+      }
+    }
+    return String.valueOf(stack.peek());
+  }
 }

From b90de9cf1fac61a3d214a9326ee7fddd4635eb32 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 7 Jul 2020 10:51:13 -0500
Subject: [PATCH 0216/2175] Modified 2 solutions

---
 Easy/Add Digits.java           | 26 +++++-------------
 Medium/Combination Sum II.java | 48 ++++++++++++++++------------------
 2 files changed, 29 insertions(+), 45 deletions(-)

diff --git a/Easy/Add Digits.java b/Easy/Add Digits.java
index ab8979b4..c701c82a 100644
--- a/Easy/Add Digits.java	
+++ b/Easy/Add Digits.java	
@@ -1,29 +1,17 @@
 class Solution {
   public int addDigits(int num) {
-    while (isDigitCountGreaterThanOne(num)) {
+    while (String.valueOf(num).length() > 1) {
       num = getDigitSum(num);
     }
     return num;
   }
   
-  private int getDigitSum(int num) {
-    int sum = 0;
-    while (num > 0) {
-      sum += num % 10;
-      num /= 10;
+  private int getDigitSum(int n) {
+    int newNum = 0;
+    while (n > 0) {
+      newNum += n % 10;
+      n /= 10;
     }
-    return sum;
-  }
-  
-  private boolean isDigitCountGreaterThanOne(int num) {
-    int count = 0;
-    while (num > 0) {
-      num /= 10;
-      count++;
-      if (count > 1) {
-        return true;
-      }
-    }
-    return false;
+    return newNum;
   }
 }
diff --git a/Medium/Combination Sum II.java b/Medium/Combination Sum II.java
index 7e66b79d..5b525f70 100644
--- a/Medium/Combination Sum II.java	
+++ b/Medium/Combination Sum II.java	
@@ -1,30 +1,26 @@
 class Solution {
-    public static List<List<Integer>> combinationSum2(int[] candidates, int target) {
-        Arrays.sort(candidates);
-        List<List<Integer>> perms = new ArrayList<>();
-        List<Integer> temp = new ArrayList<>();
-
-        combinationSumHelper(candidates, target, perms, temp, 0);
-
-        return perms;
+  public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+    List<List<Integer>> list = new ArrayList<>();
+    Arrays.sort(candidates);
+    helper(candidates, 0, target, new ArrayList<>(), list);
+    return list;
+  }
+  
+  private void helper(int[] candidates, int idx, int target, List<Integer> temp, List<List<Integer>> list) {
+    if (target == 0) {
+      list.add(new ArrayList<>(temp));
+      return;
     }
-
-    private static void combinationSumHelper(int[] candidates, int target, List<List<Integer>> perms, List<Integer> temp, int start) {
-        if (target < 0) {
-            return;
-        }
-        if (target == 0) {
-            perms.add(new ArrayList<>(temp));
-        }
-        else {
-            for (int i=start; i<candidates.length; i++) {
-                if (i > start && candidates[i] == candidates[i-1]) {
-                    continue;
-                }
-                temp.add(candidates[i]);
-                combinationSumHelper(candidates, target-candidates[i], perms, temp, i+1);
-                temp.remove(temp.size()-1);
-            }
-        }
+    if (target < 0) {
+      return;
     }
+    for (int i = idx; i < candidates.length; i++) {
+      if (i > idx && candidates[i] == candidates[i - 1]) { 
+        continue;
+      }
+      temp.add(candidates[i]);
+      helper(candidates, i + 1, target - candidates[i], temp, list);
+      temp.remove(temp.size() - 1);
+    }
+  }
 }

From 4100cfbc5432f4636c7c84026686f0c83e5b50f0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 8 Jul 2020 10:30:17 -0500
Subject: [PATCH 0217/2175] Modified 4 solutions

---
 Easy/Design HashMap.java                  | 52 +++++++++++++--------
 Easy/K-diff Pairs in an Array.java        | 47 ++++++++-----------
 Medium/3Sum.java                          | 36 ++++++---------
 Medium/Binary Tree Inorder Traversal.java | 56 ++++++++++++-----------
 4 files changed, 98 insertions(+), 93 deletions(-)

diff --git a/Easy/Design HashMap.java b/Easy/Design HashMap.java
index 2738efa9..d59fe9e1 100644
--- a/Easy/Design HashMap.java	
+++ b/Easy/Design HashMap.java	
@@ -1,26 +1,42 @@
 class MyHashMap {
 
-    /** Initialize your data structure here. */
-    int[] arr;
-    public MyHashMap() {
-        arr = new int[1000001];
-        Arrays.fill(arr, -1);
-    }
+  /** Initialize your data structure here. */
+  Integer[][] map;
+  int NUM_OF_BUCKETS = 1000;
+  int BUCKET_SIZE = 1000;
+  public MyHashMap() {
+    map = new Integer[NUM_OF_BUCKETS][BUCKET_SIZE];
+  }
 
-    /** value will always be non-negative. */
-    public void put(int key, int value) {
-        arr[key] = value;
-    }
+  /** value will always be non-negative. */
+  public void put(int key, int value) {
+    Integer[] bucket = getBucket(key);
+    int keyHash = getKeyHash(key);
+    bucket[keyHash] = value;
+  }
 
-    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
-    public int get(int key) {
-        return arr[key];
-    }
+  /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
+  public int get(int key) {
+    Integer[] bucket = getBucket(key);
+    int keyHash = getKeyHash(key);
+    return bucket[keyHash] == null ? -1 : bucket[keyHash];
+  }
 
-    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
-    public void remove(int key) {
-        arr[key] = -1;
-    }
+  /** Removes the mapping of the specified value key if this map contains a mapping for the key */
+  public void remove(int key) {
+    Integer[] bucket = getBucket(key);
+    int keyHash = getKeyHash(key);
+    bucket[keyHash] = null;
+  }
+  
+  private Integer[] getBucket(int key) {
+    int bucketIdx = key / BUCKET_SIZE;
+    return map[bucketIdx];
+  }
+  
+  private Integer getKeyHash(int key) {
+    return key % BUCKET_SIZE;
+  }
 }
 
 /**
diff --git a/Easy/K-diff Pairs in an Array.java b/Easy/K-diff Pairs in an Array.java
index a5692dd5..72aef035 100644
--- a/Easy/K-diff Pairs in an Array.java	
+++ b/Easy/K-diff Pairs in an Array.java	
@@ -1,31 +1,24 @@
 class Solution {
-    public int findPairs(int[] nums, int k) {
-        if (nums.length <= 1 || k<0) {
-            return 0;
+  public int findPairs(int[] nums, int k) {
+    Arrays.sort(nums);
+    int left = 0;
+    int right = 1;
+    int count = 0;
+    while (left < nums.length && right < nums.length) {
+      if (left == right || nums[right] - nums[left] < k) {
+        right++;
+      }
+      else if (nums[right] - nums[left] > k) {
+        left++;
+      }
+      else {
+        left++;
+        count++;
+        while (left < nums.length && nums[left] == nums[left - 1]) {
+          left++;
         }
-        Map<Integer, Integer> map = new HashMap<>();
-        int count = 0;
-        for (int i:nums) {
-            if (map.containsKey(i)) {
-                map.put(i, map.get(i)+1);
-            }
-            else {
-                map.put(i,1);
-            }
-        }
-        
-        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            if (k==0) {
-                if (entry.getValue() >= 2) {
-                    count++;
-                } 
-            }
-            else {
-                if (map.containsKey(entry.getKey() + k)) {
-                    count++;
-                }
-            }
-        }
-        return count;
+      }
     }
+    return count;
+  }
 }
diff --git a/Medium/3Sum.java b/Medium/3Sum.java
index 0bf94c28..e959d745 100644
--- a/Medium/3Sum.java
+++ b/Medium/3Sum.java
@@ -1,35 +1,29 @@
 class Solution {
   public List<List<Integer>> threeSum(int[] nums) {
-    Set<List<Integer>> set = new HashSet<>();
     Arrays.sort(nums);
-    for (int i = 0; i < nums.length; i++) {
-      for (int j = i + 1; j < nums.length; j++) {
-        int idx = binarySearchHelper(nums, j + 1, nums.length - 1, -1 * (nums[i] + nums[j]));
-        if (idx != -1) {
-          List<Integer> temp = new ArrayList<>();
-          temp.add(nums[i]);
-          temp.add(nums[j]);
-          temp.add(nums[idx]);
-          set.add(temp);
-        }
+    List<List<Integer>> list = new ArrayList<>();
+    for (int i = 0; i < nums.length && nums[i] <= 0; i++) {
+      if (i == 0 || nums[i - 1] != nums[i]) {
+        twoSumHelper(nums, i, list);
       }
     }
-    return new ArrayList<>(set);
+    return list;
   }
   
-  private int binarySearchHelper(int[] nums, int start, int end, int target) {
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (nums[mid] == target) {
-        return mid;
+  private void twoSumHelper(int[] nums, int i, List<List<Integer>> list) {
+    int low = i + 1;
+    int high = nums.length - 1;
+    while (low < high) {
+      int sum = nums[i] + nums[low] + nums[high];
+      if (sum < 0 || (low > i + 1 && nums[low] == nums[low - 1])) {
+        low++;
       }
-      else if (nums[mid] > target) {
-        end = mid - 1;
+      else if (sum > 0 || (high < nums.length - 1 && nums[high] == nums[high + 1])) {
+        high--;
       }
       else {
-        start = mid + 1;
+        list.add(Arrays.asList(nums[i], nums[low++], nums[high--]));
       }
     }
-    return -1;
   }
 }
diff --git a/Medium/Binary Tree Inorder Traversal.java b/Medium/Binary Tree Inorder Traversal.java
index d071d5e0..aad98c4b 100644
--- a/Medium/Binary Tree Inorder Traversal.java	
+++ b/Medium/Binary Tree Inorder Traversal.java	
@@ -4,35 +4,37 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public List<Integer> inorderTraversal(TreeNode root) {
-        Stack<TreeNode> s = new Stack<>();
-        ArrayList<Integer> arr = new ArrayList<>();
-        
-        TreeNode curr = root;
-    
-        while(curr != null) {
-            s.push(curr);
-            curr = curr.left;
-        }
-        
-        while(s.size() > 0) {
-            curr = s.pop();
-            arr.add(curr.val);
-            
-            if (curr.right != null) {
-                curr = curr.right;
-                
-                while(curr != null) {
-                    s.push(curr);
-                    curr = curr.left;
-                }
-            }
-        }
-        
-        return arr;
+  public List<Integer> inorderTraversal(TreeNode root) {
+    List<Integer> list = new ArrayList<>();
+    if (root == null) {
+      return list;
     }
+    Stack<TreeNode> stack = new Stack<>();
+    stack.push(root);
+    root = root.left;
+    while (root != null) {
+      stack.push(root);
+      root = root.left;
+    }
+    while (!stack.isEmpty()) {
+      TreeNode removed = stack.pop();
+      list.add(removed.val);
+      removed = removed.right;
+      while (removed != null) {
+        stack.push(removed);
+        removed = removed.left;
+      }
+    }
+    return list;
+  }
 }

From a80f39de0513e3beaadb6d428ce1f4bdbeec6108 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 8 Jul 2020 17:25:58 -0500
Subject: [PATCH 0218/2175] Added 1 solution & modified 1 solution

---
 Medium/Reconstruct Itinerary.java             | 68 +++++++++++++------
 ...um Consecutive Nodes from Linked List.java | 33 +++++++++
 2 files changed, 80 insertions(+), 21 deletions(-)
 create mode 100644 Medium/Remove Zero Sum Consecutive Nodes from Linked List.java

diff --git a/Medium/Reconstruct Itinerary.java b/Medium/Reconstruct Itinerary.java
index c98913d2..68d6598b 100644
--- a/Medium/Reconstruct Itinerary.java	
+++ b/Medium/Reconstruct Itinerary.java	
@@ -1,25 +1,51 @@
 class Solution {
-    public List<String> findItinerary(List<List<String>> tickets) {
-        Map<String, PriorityQueue<String>> map = new HashMap<>();
-        for (List<String> ticket : tickets) {
-            map.computeIfAbsent(ticket.get(0), k -> new PriorityQueue<>()).add(ticket.get(1));
-        }
-
-        List<String> route = new ArrayList<>();
-        Stack<String> stack = new Stack<>();
-
-        stack.push("JFK");
-
-        while (!stack.isEmpty()) {
-            while (map.containsKey(stack.peek()) && !map.get(stack.peek()).isEmpty()) {
-                stack.push(map.get(stack.peek()).poll());
-            }
-
-            route.add(stack.pop());
+  List<String> result = null;
+  public List<String> findItinerary(List<List<String>> tickets) {
+    Map<String, List<String>> map = new HashMap<>();
+    Map<String, boolean[]> visitMap = new HashMap<>();
+    int flights = tickets.size();
+    for (List<String> ticket : tickets) {
+      map.computeIfAbsent(ticket.get(0), k -> new ArrayList<>()).add(ticket.get(1));
+    }
+    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
+      Collections.sort(entry.getValue());
+      visitMap.put(entry.getKey(), new boolean[entry.getValue().size()]);
+    }
+    LinkedList<String> route = new LinkedList<String>();
+    route.add("JFK");
+    backtrack(map, visitMap, flights, route, "JFK");
+    return result;
+  }
+  
+  private boolean backtrack(
+    Map<String, List<String>> map,
+    Map<String, boolean[]> visitMap,
+    int flights,
+    LinkedList<String> route,
+    String origin
+  ) {
+    if (route.size() == (flights + 1)) {
+      result = (List<String>) route.clone();
+      return true;
+    }
+    if (!map.containsKey(origin)) {
+      return false;
+    }
+    int i = 0;
+    boolean[] visited = visitMap.get(origin);
+    for (String dest : map.get(origin)) {
+      if (!visited[i]) {
+        visited[i] = true;
+        route.add(dest);
+        boolean res = backtrack(map, visitMap, flights, route, dest);
+        route.pollLast();
+        visited[i] = false;
+        if (res == true) {
+          return true;
         }
-
-        Collections.reverse(route);
-
-        return route;
+      }
+      i++;
     }
+    return false;
+  }
 }
diff --git a/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java b/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java
new file mode 100644
index 00000000..9807ca95
--- /dev/null
+++ b/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java	
@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode removeZeroSumSublists(ListNode head) {
+    ListNode dummy = new ListNode(0);
+    ListNode curr = head;
+    dummy.next = head;
+    Map<Integer, ListNode> map = new HashMap<>();
+    int prefixSum = 0;
+    map.put(0, dummy);
+    while (curr != null) {
+      prefixSum += curr.val;
+      map.put(prefixSum, curr);
+      curr = curr.next;
+    }
+    prefixSum = 0;
+    curr = dummy;
+    while (curr != null) {
+      prefixSum += curr.val;
+      curr.next = map.get(prefixSum).next;
+      curr = curr.next;
+    }
+    return dummy.next;
+  }
+}

From 0c9fd97fd7268b7eaa4318ddee031bd38d72e8c3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 9 Jul 2020 10:39:15 -0500
Subject: [PATCH 0219/2175] Modified 4 solutions

---
 Easy/Cousins in Binary Tree.java              | 46 ++++++++--------
 Medium/4Sum.java                              | 54 ++++++++-----------
 Medium/Insertion Sort List.java               | 38 ++++++-------
 Medium/Search in Rotated Sorted Array II.java | 40 +++++++++++---
 4 files changed, 93 insertions(+), 85 deletions(-)

diff --git a/Easy/Cousins in Binary Tree.java b/Easy/Cousins in Binary Tree.java
index 5b12a341..21c6431d 100644
--- a/Easy/Cousins in Binary Tree.java	
+++ b/Easy/Cousins in Binary Tree.java	
@@ -4,42 +4,38 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public boolean isCousins(TreeNode root, int x, int y) {
-    if (root == null || x == y) {
-      return true;
-    }
-    ParentData p1 = new ParentData();
-    ParentData p2 = new ParentData();
-    helper(root, x, 0, null, p1);
-    helper(root, y, 0, null, p2);
-    return p1.depth == p2.depth && p1.parent != p2.parent;
+    int[] depthAndParentX = {0, 0};
+    int[] depthAndParentY = {0, 0};
+    helper(root, x, 0, null, depthAndParentX);
+    helper(root, y, 0, null, depthAndParentY);
+    return depthAndParentX[0] == depthAndParentY[0] && depthAndParentX[1] != depthAndParentY[1];
   }
   
-  private void helper(TreeNode root, int x, int currDepth, TreeNode parent, ParentData p) {
+  private void helper(
+    TreeNode root, int num, int currDepth, TreeNode currParent, int[] depthAndParent
+  ) {
     if (root == null) {
       return;
     }
-    if (root.val == x) {
-      p.depth = currDepth;
-      p.parent = parent;
+    if (root.val == num) {
+      System.out.println(root.val + " " + num + " " + (currParent == null ? -1 : currParent.val));
+      depthAndParent[0] = currDepth;
+      depthAndParent[1] = currParent == null ? -1 : currParent.val;
     }
     else {
-      helper(root.left, x, currDepth + 1, root, p);
-      helper(root.right, x, currDepth + 1, root, p);
+      helper(root.left, num, currDepth + 1, root, depthAndParent);
+      helper(root.right, num, currDepth + 1, root, depthAndParent);
     }
   }
 }
-
-class ParentData {
-  int depth;
-  TreeNode parent;
-  
-  public ParentData() {
-    this.depth = 0;
-    this.parent = null;
-  }
-}
diff --git a/Medium/4Sum.java b/Medium/4Sum.java
index 8c4fdf7b..41f71e4a 100644
--- a/Medium/4Sum.java
+++ b/Medium/4Sum.java
@@ -1,37 +1,25 @@
 class Solution {
-    public static List<List<Integer>> fourSum(int[] nums, int target) {
-        Set<List<Integer>> ans = new HashSet<>();
-
-        Arrays.sort(nums);
-
-        for (int i=0; i<nums.length; i++) {
-            for (int j=i+1; j<nums.length; j++) {
-                int temp = target - (nums[i] + nums[j]);
-                int start = j+1;
-                int end = nums.length-1;
-
-                while (start < end) {
-                    if (nums[start] + nums[end] == temp) {
-                        List<Integer> list = new ArrayList<>();
-                        list.add(nums[i]);
-                        list.add(nums[j]);
-                        list.add(nums[start]);
-                        list.add(nums[end]);
-
-                        ans.add(list);
-                        start++;
-                        end--;
-                    }
-                    else if (nums[start] + nums[end] < temp) {
-                        start++;
-                    }
-                    else if (nums[start] + nums[end] > temp) {
-                        end--;
-                    }
-                }
-            }
+  public List<List<Integer>> fourSum(int[] nums, int target) {
+    Arrays.sort(nums);
+    Set<List<Integer>> set = new HashSet<>();
+    for (int i = 0; i < nums.length; i++) {
+      for (int j = i + 1; j < nums.length; j++) {
+        int newTarget = target - nums[i] - nums[j];
+        int start = j + 1;
+        int end = nums.length - 1;
+        while (start < end) {
+          if ((nums[start] + nums[end]) == newTarget) {
+            set.add(Arrays.asList(nums[i], nums[j], nums[start++], nums[end--]));
+          }
+          else if ((nums[start] + nums[end]) < newTarget) {
+            start++;
+          }
+          else {
+            end--;
+          }
         }
-
-        return new ArrayList<>(ans);
+      }
     }
+    return new ArrayList<>(set);
+  }
 }
diff --git a/Medium/Insertion Sort List.java b/Medium/Insertion Sort List.java
index b3817b60..798e311b 100644
--- a/Medium/Insertion Sort List.java	
+++ b/Medium/Insertion Sort List.java	
@@ -3,27 +3,27 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode insertionSortList(ListNode head) {
-        ListNode temp = head;
-        while (temp != null) {
-            ListNode curr =temp;
-            int v = curr.val;
-            ListNode t = temp;
-            while (curr != null) {
-                if (curr.val < v) {
-                    v = curr.val;
-                    t = curr;
-                }
-                curr = curr.next;
-            }
-            t.val = temp.val;
-            temp.val = v;
-            temp = temp.next;
-        }
-        return head;
+  public ListNode insertionSortList(ListNode head) {
+    ListNode dummy = new ListNode(0);
+    ListNode curr = head;
+    ListNode prev = dummy;
+    ListNode next = null;
+    while (curr != null) {
+      next = curr.next;
+      while (prev.next != null && prev.next.val < curr.val) {
+        prev = prev.next;
+      }
+      curr.next = prev.next;
+      prev.next = curr;
+      prev = dummy;
+      curr = next;
     }
+    return dummy.next; 
+  }
 }
diff --git a/Medium/Search in Rotated Sorted Array II.java b/Medium/Search in Rotated Sorted Array II.java
index 46baafb6..83c15734 100644
--- a/Medium/Search in Rotated Sorted Array II.java	
+++ b/Medium/Search in Rotated Sorted Array II.java	
@@ -1,11 +1,35 @@
 class Solution {
-    public boolean search(int[] nums, int target) {
-        for(int i=0;i<nums.length;i++) {
-            if(nums[i] == target) {
-                return true;
-            }
-        }
-        
-        return false;
+  public boolean search(int[] nums, int target) {
+    int start = 0;
+    int end = nums.length - 1;
+    int mid = -1;
+    while (start <= end) {
+      mid = (start + end) / 2;
+      if (nums[mid] == target) {
+        return true;
+      }
+      // Either right side is sorted or left side is unsorted
+      if (nums[mid] < nums[end] || nums[mid] < nums[start]) {
+        if (target > nums[mid] && target <= nums[end]) {
+          start = mid + 1;
+        }
+        else {
+          end = mid - 1;
+        }
+      }
+      // Either left side is sorted or right side is unsorted
+      else if (nums[mid] > nums[start] || nums[mid] > nums[end]) {
+        if (target < nums[mid] && target >= nums[start]) {
+          end = mid - 1;
+        }
+        else {
+          start = mid + 1;
+        }
+      }
+      else {
+        end--;
+      }
     }
+    return false;
+  }   
 }

From 9bfe3b29d9b1e4fe861fda999de592a0447bd5c6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 10 Jul 2020 10:03:18 -0500
Subject: [PATCH 0220/2175] Added 1 solution & modified 3 solutions

---
 Easy/Detect Capital.java                      | 50 +++++-----
 Easy/Max Stack.java                           | 93 ++++++++-----------
 Medium/Find Root of N-Ary Tree.java           | 39 ++++++++
 ...atten a Multilevel Doubly Linked List.java | 58 +++++-------
 4 files changed, 127 insertions(+), 113 deletions(-)
 create mode 100644 Medium/Find Root of N-Ary Tree.java

diff --git a/Easy/Detect Capital.java b/Easy/Detect Capital.java
index 60b5cae1..b9431060 100644
--- a/Easy/Detect Capital.java	
+++ b/Easy/Detect Capital.java	
@@ -1,26 +1,28 @@
-public class Solution {
-    public boolean detectCapitalUse(String word) {
-        boolean capitalFirst = Character.isUpperCase(word.charAt(0));
-        if (word.length() > 1) {
-            boolean capitalSec = Character.isUpperCase(word.charAt(1));
-            for (int i=1;i<word.length();i++) {
-                if (capitalFirst && capitalSec) {
-                    if (Character.isUpperCase(word.charAt(i)) == false) {
-                        return false;
-                    }
-                }
-                else if (capitalFirst && capitalSec == false) {
-                    if (Character.isUpperCase(word.charAt(i)) == true) {
-                        return false;
-                    }
-                }
-                else {
-                    if (Character.isUpperCase(word.charAt(i)) == true) {
-                        return false;
-                    }
-                }
-            }
+class Solution {
+  public boolean detectCapitalUse(String word) {
+    int n = word.length();
+    boolean capitalFirst = Character.isUpperCase(word.charAt(0));
+    int idx = 1;
+    if (idx < n) {
+      boolean capitalSecond = Character.isUpperCase(word.charAt(idx));
+      for (idx = 1; idx < n; idx++) {
+        if (capitalFirst && capitalSecond) {
+          if (Character.isLowerCase(word.charAt(idx))) {
+            return false;
+          }
         }
-        return true;
+        else if (capitalFirst && !capitalSecond) {
+          if (Character.isUpperCase(word.charAt(idx))) {
+            return false;
+          }
+        }
+        else {
+          if (Character.isUpperCase(word.charAt(idx))) {
+            return false;
+          }
+        }
+      }
     }
-}
\ No newline at end of file
+    return true;
+  }
+}
diff --git a/Easy/Max Stack.java b/Easy/Max Stack.java
index 8040a2c0..3125c3d0 100644
--- a/Easy/Max Stack.java	
+++ b/Easy/Max Stack.java	
@@ -1,62 +1,45 @@
 class MaxStack {
 
-    /** initialize your data structure here. */
-    Stack<Integer> stack;
-    Stack<Integer> maxStack;
-    
-    public MaxStack() {
-        stack = new Stack<>();
-        maxStack = new Stack<>();
-    }
-    
-    public void push(int x) {
-        stack.push(x);
-        if (maxStack.isEmpty()) {
-            maxStack.push(x);
-        }
-        else {
-            maxStack.push(Math.max(maxStack.peek(), x));
-        }
-    }
-    
-    public int pop() {
-        int val = stack.pop();
-        maxStack.pop();
-        return val;
-    }
-    
-    public int top() {
-        return stack.peek();
-    }
-    
-    public int peekMax() {
-        return maxStack.peek();
+  /** initialize your data structure here. */
+  Stack<Integer> stack;
+  Stack<Integer> max;
+  public MaxStack() {
+    stack = new Stack<>();
+    max = new Stack<>();
+  }
+
+  public void push(int x) {
+    stack.push(x);
+    max.push(max.isEmpty() ? x : Math.max(x, max.peek()));
+  }
+
+  public int pop() {
+    max.pop();
+    return stack.pop();
+  }
+
+  public int top() {
+    return stack.peek();
+  }
+
+  public int peekMax() {
+    return max.peek();
+  }
+
+  public int popMax() {
+    int num = max.peek();
+    Stack<Integer> temp = new Stack<>();
+    while (stack.peek() != num) {
+      temp.push(stack.pop());
+      max.pop();
     }
-    
-    public int popMax() {
-        int maxOnTop = maxStack.peek();
-        Stack<Integer> temp = new Stack<>();
-        while (stack.peek() != maxOnTop) {
-            temp.add(stack.pop());
-            maxStack.pop();
-        }
-        
-        stack.pop();
-        maxStack.pop();
-        
-        while (!temp.isEmpty()) {
-            int popped = temp.pop();
-            stack.push(popped);
-            if (maxStack.isEmpty()) {
-                maxStack.push(popped);
-            }
-            else {
-                maxStack.push(Math.max(popped, maxStack.peek()));
-            }
-        }
-        
-        return maxOnTop;
+    max.pop();
+    stack.pop();
+    while (!temp.isEmpty()) {
+      push(temp.pop());
     }
+    return num;
+  } 
 }
 
 /**
diff --git a/Medium/Find Root of N-Ary Tree.java b/Medium/Find Root of N-Ary Tree.java
new file mode 100644
index 00000000..be5c9166
--- /dev/null
+++ b/Medium/Find Root of N-Ary Tree.java	
@@ -0,0 +1,39 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    
+    public Node() {
+        children = new ArrayList<Node>();
+    }
+    
+    public Node(int _val) {
+        val = _val;
+        children = new ArrayList<Node>();
+    }
+    
+    public Node(int _val,ArrayList<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+  public Node findRoot(List<Node> tree) {
+    Set<Node> set = new HashSet<>();
+    for (Node node : tree) {
+      for (Node child : node.children) {
+        set.add(child);
+      }
+    }
+    for (Node node : tree) {
+      if (!set.contains(node)) {
+        return node;
+      }
+    }
+    return null;
+  }
+}
diff --git a/Medium/Flatten a Multilevel Doubly Linked List.java b/Medium/Flatten a Multilevel Doubly Linked List.java
index 1c6c4894..47dfdbb2 100644
--- a/Medium/Flatten a Multilevel Doubly Linked List.java	
+++ b/Medium/Flatten a Multilevel Doubly Linked List.java	
@@ -5,43 +5,33 @@ class Node {
     public Node prev;
     public Node next;
     public Node child;
-
-    public Node() {}
-
-    public Node(int _val,Node _prev,Node _next,Node _child) {
-        val = _val;
-        prev = _prev;
-        next = _next;
-        child = _child;
-    }
 };
 */
+
 class Solution {
-    Node ans;
-    Node curr;
-    public Node flatten(Node head) {
-        ans = new Node(-1);
-        curr = ans;
-        
-        helper(head);
-        
-        return ans.next;
+  public Node flatten(Node head) {
+    if (head == null) {
+      return null;
     }
-    
-    private void helper(Node node) {
-        if (node == null) {
-            return;
-        }
-        
-        Node prev = curr;
-        curr.next = new Node(node.val);
-        curr = curr.next;
-        curr.prev = prev.val == -1 ? null : prev;
-        
-        if (node.child != null) {
-            helper(node.child);
-        }
-        
-        helper(node.next);
+    Stack<Node> stack = new Stack<>();
+    stack.push(head);
+    Node dummy = new Node(0, null, head, null);
+    Node prev = dummy;
+    Node curr = dummy;
+    while (!stack.isEmpty()) {
+      curr = stack.pop();
+      prev.next = curr;
+      curr.prev = prev;
+      if (curr.next != null) {
+        stack.push(curr.next);
+      }
+      if (curr.child != null) {
+        stack.push(curr.child);
+        curr.child = null;
+      }
+      prev = curr;
     }
+    dummy.next.prev = null;
+    return dummy.next;
+  }
 }

From f684279a472ba827f07ba684212d5849cbb0dae2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 11 Jul 2020 18:06:55 -0500
Subject: [PATCH 0221/2175] Added 2 solutions & modified 1 solution

---
 Easy/Reformat Date.java                       | 16 ++++++++++
 Medium/Range Sum of Sorted Subarray Sums.java | 26 ++++++++++++++++
 Medium/Subsets.java                           | 31 ++++++++-----------
 3 files changed, 55 insertions(+), 18 deletions(-)
 create mode 100644 Easy/Reformat Date.java
 create mode 100644 Medium/Range Sum of Sorted Subarray Sums.java

diff --git a/Easy/Reformat Date.java b/Easy/Reformat Date.java
new file mode 100644
index 00000000..fdde8bc3
--- /dev/null
+++ b/Easy/Reformat Date.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public String reformatDate(String date) {
+    String[] months = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+    Map<String, String> monthMap = new HashMap<>();
+    for (int i = 1; i <= 12; i++) {
+      monthMap.put(months[i - 1], (i > 9 ? "" : "0") + i);
+    }
+    String[] strs = date.split("\\s+");
+    int dayEndIdx = 0;
+    while (dayEndIdx < strs[0].length() && Character.isDigit(strs[0].charAt(dayEndIdx))) {
+      dayEndIdx++;
+    }
+    String dayStr = strs[0].substring(0, dayEndIdx);
+    return strs[2] + "-" + monthMap.get(strs[1]) + "-" + (dayStr.length() == 2 ? dayStr : "0" + dayStr);
+  }
+}
diff --git a/Medium/Range Sum of Sorted Subarray Sums.java b/Medium/Range Sum of Sorted Subarray Sums.java
new file mode 100644
index 00000000..c8dad58b
--- /dev/null
+++ b/Medium/Range Sum of Sorted Subarray Sums.java	
@@ -0,0 +1,26 @@
+class Solution {
+  final int MOD = 100000007;
+  public int rangeSum(int[] nums, int n, int left, int right) {
+    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
+      public int compare(int[] o1, int[] o2) {
+        return o1[0] - o2[0];
+      }
+    });
+    for (int i = 0; i < n; i++) {
+      pq.add(new int[]{nums[i], i + 1});
+    }
+    int sum = 0;
+    for (int i = 1; i <= right; i++) {
+      int[] removed = pq.poll();
+      if (i >= left) {
+        sum = (sum + removed[0]) % MOD;
+      }
+      if (removed[1] < n) {
+        removed[0] = removed[0] + nums[removed[1]];
+        removed[1]++;
+        pq.add(removed);
+      }
+    }
+    return sum;
+  }
+}
diff --git a/Medium/Subsets.java b/Medium/Subsets.java
index 9444e97f..753aa998 100644
--- a/Medium/Subsets.java
+++ b/Medium/Subsets.java
@@ -1,21 +1,16 @@
 class Solution {
-    public static List<List<Integer>> subsets(int[] nums) {
-
-        Arrays.sort(nums);
-        List<List<Integer>> perms = new ArrayList<>();
-        List<Integer> temp = new ArrayList<>();
-        subsetsHelper(nums, perms, temp, 0);
-
-        return perms;
-    }
-
-    private static void subsetsHelper(int[] nums, List<List<Integer>> perms, List<Integer> temp, int start) {
-        perms.add(new ArrayList<>(temp));
-
-        for (int i=start; i<nums.length; i++) {
-            temp.add(nums[i]);
-            subsetsHelper(nums, perms, temp, i+1);
-            temp.remove(temp.size()-1);
-        }
+  public List<List<Integer>> subsets(int[] nums) {
+    Set<List<Integer>> set = new HashSet<>();
+    helper(nums, 0, new ArrayList<>(), set);
+    return new ArrayList<>(set);
+  }
+  
+  private void helper(int[] nums, int idx, List<Integer> temp, Set<List<Integer>> set) {
+    set.add(new ArrayList<>(temp));
+    for (int i = idx; i < nums.length; i++) {
+      temp.add(nums[i]);
+      helper(nums, i + 1, temp, set);
+      temp.remove(temp.size() - 1);
     }
+  }
 }

From f2995fe91d57f55f3e244d69aab9c6377046dd37 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 12 Jul 2020 10:54:19 -0500
Subject: [PATCH 0222/2175] Added 3 solutions & modified 1 solution

---
 Easy/Letter Case Permutation.java             | 46 +++++++++++--------
 Easy/Number of Good Pairs.java                | 11 +++++
 Easy/Reverse Bits.java                        | 19 ++++----
 Medium/Number of Substrings With Only 1s.java | 14 ++++++
 4 files changed, 61 insertions(+), 29 deletions(-)
 create mode 100644 Easy/Number of Good Pairs.java
 create mode 100644 Medium/Number of Substrings With Only 1s.java

diff --git a/Easy/Letter Case Permutation.java b/Easy/Letter Case Permutation.java
index a9f2b640..c451655c 100644
--- a/Easy/Letter Case Permutation.java	
+++ b/Easy/Letter Case Permutation.java	
@@ -1,23 +1,31 @@
 class Solution {
-    public List<String> letterCasePermutation(String S) {
-        List<String> ans = new ArrayList<>();
-        letterCasePermutationHelper(ans, S.toCharArray(), 0);
-
-        return ans;
+  public List<String> letterCasePermutation(String S) {
+    Set<String> set = new HashSet<>();
+    helper(S, 0, set, new StringBuilder());
+    return new ArrayList<>(set);
+  }
+  
+  private void helper(String s, int idx, Set<String> set, StringBuilder sb) {
+    if (idx == s.length()) {
+      if (sb.length() > 0) {
+        set.add(new StringBuilder(sb.toString()).toString());
+      }
     }
-
-    private void letterCasePermutationHelper(List<String> ans, char[] chars, int index) {
-        if (index == chars.length) {
-            ans.add(new String(chars));
-        }
-        else {
-            if (Character.isLetter(chars[index])) {
-                chars[index] = Character.toLowerCase(chars[index]);
-                letterCasePermutationHelper(ans, chars, index+1);
-                chars[index] = Character.toUpperCase(chars[index]);
-            }
-
-            letterCasePermutationHelper(ans, chars, index+1);
-        }
+    else {
+      char c = s.charAt(idx);
+      if (Character.isDigit(c)) {
+        sb.append(c);
+        helper(s, idx + 1, set, sb);
+        sb.deleteCharAt(sb.length() - 1);
+      }
+      else {
+        sb.append(Character.toLowerCase(c));
+        helper(s, idx + 1, set, sb);
+        sb.deleteCharAt(sb.length() - 1);
+        sb.append(Character.toUpperCase(c));
+        helper(s, idx + 1, set, sb);
+        sb.deleteCharAt(sb.length() - 1);
+      }
     }
+  }
 }
diff --git a/Easy/Number of Good Pairs.java b/Easy/Number of Good Pairs.java
new file mode 100644
index 00000000..d3c347af
--- /dev/null
+++ b/Easy/Number of Good Pairs.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int numIdenticalPairs(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int count = 0;
+    for (int num : nums) {
+      count += map.getOrDefault(num, 0);
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    return count;
+  }
+}
diff --git a/Easy/Reverse Bits.java b/Easy/Reverse Bits.java
index 59b9fc7f..e2406b6c 100644
--- a/Easy/Reverse Bits.java	
+++ b/Easy/Reverse Bits.java	
@@ -1,12 +1,11 @@
 public class Solution {
-    public int reverseBits(int n) {
-        int result = 0;
-        for (int i = 0; i < 32; i++) {
-            result += n & 1;
-            n >>>= 1;   
-            if (i < 31) 
-                result <<= 1;
-        }
-        return result;
+  public int reverseBits(int n) {
+    int res = 0;
+    for (int i = 0; i < 32; i++) {
+      res <<= 1;
+      res = res | (n & 1);
+      n >>= 1;
     }
-}
\ No newline at end of file
+    return res;
+  }
+}
diff --git a/Medium/Number of Substrings With Only 1s.java b/Medium/Number of Substrings With Only 1s.java
new file mode 100644
index 00000000..64febaeb
--- /dev/null
+++ b/Medium/Number of Substrings With Only 1s.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int numSub(String s) {
+    long ans = 0;
+    for (int i = 0; i < s.length(); i++) {
+      long count = 0;
+      while (i < s.length() && s.charAt(i) == '1') {
+        i++;
+        count++;
+      }
+      ans = (ans + (count * (count + 1)) / 2) % 1000000007;
+    }
+    return (int) ans;
+  }
+}

From 035af3f20bb55eec89d2f47cd4e7f39a753a2751 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 12 Jul 2020 20:46:25 -0500
Subject: [PATCH 0223/2175] Added 2 solutions

---
 ... of Neighbors at a Threshold Distance.java | 37 ++++++++++++++++++
 Medium/Path with Maximum Probability.java     | 38 +++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 Medium/Find the City With the Smallest Number of Neighbors at a Threshold Distance.java
 create mode 100644 Medium/Path with Maximum Probability.java

diff --git a/Medium/Find the City With the Smallest Number of Neighbors at a Threshold Distance.java b/Medium/Find the City With the Smallest Number of Neighbors at a Threshold Distance.java
new file mode 100644
index 00000000..08292d1d
--- /dev/null
+++ b/Medium/Find the City With the Smallest Number of Neighbors at a Threshold Distance.java	
@@ -0,0 +1,37 @@
+class Solution {
+  public int findTheCity(int n, int[][] edges, int distanceThreshold) {
+    Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
+    for (int[] edge : edges) {
+      map.computeIfAbsent(edge[0], k -> new HashMap<>()).put(edge[1], edge[2]);
+      map.computeIfAbsent(edge[1], k -> new HashMap<>()).put(edge[0], edge[2]);
+    }
+    int min = n + 1;
+    int res = -1;
+    for (int i = 0; i < n; i++) {
+      Queue<int[]> queue = new PriorityQueue<>((a, b) -> (b[1] - a[1]));
+      queue.add(new int[]{i, distanceThreshold});
+      boolean[] visited = new boolean[n];
+      int count = 0;
+      while (!queue.isEmpty()) {
+        int[] city = queue.poll();
+        if (visited[city[0]]) {
+          continue;
+        }
+        visited[city[0]] = true;
+        count++;
+        Map<Integer, Integer> temp = map.getOrDefault(city[0], new HashMap<>());
+        for (Integer neighbour : temp.keySet()) {
+          if (!visited[neighbour] && city[1] >= temp.get(neighbour)) {
+            queue.add(new int[]{neighbour, city[1] - temp.get(neighbour)});
+          }
+        }
+      }
+      if (count - 1 <= min) {
+        min = count - 1;
+        res = i;
+      }
+    }
+    return res;
+  }
+}
+
diff --git a/Medium/Path with Maximum Probability.java b/Medium/Path with Maximum Probability.java
new file mode 100644
index 00000000..d104e576
--- /dev/null
+++ b/Medium/Path with Maximum Probability.java	
@@ -0,0 +1,38 @@
+class Solution {
+  public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
+    Map<Integer, List<Node>> graph = new HashMap<>();
+    for (int i = 0; i < edges.length; i++) {
+      Node node1 = new Node(edges[i][1], succProb[i]);
+      Node node2 = new Node(edges[i][0], succProb[i]);
+      graph.computeIfAbsent(edges[i][0], k -> new ArrayList<>()).add(node1);
+      graph.computeIfAbsent(edges[i][1], k -> new ArrayList<>()).add(node2);
+    }
+    double[] probs = new double[n];
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(new Node(start, 1.0));
+    while (!queue.isEmpty()) {
+      Node node = queue.remove();
+      int parent = node.val;
+      double prob = node.prob;
+      for (Node child : graph.getOrDefault(parent, new ArrayList<>())) {
+        if (probs[child.val] >= prob * child.prob) {
+          continue;
+        }
+        queue.add(new Node(child.val, prob * child.prob));
+        probs[child.val] = prob * child.prob;
+      }
+    }
+    return probs[end];
+  }
+}
+
+
+class Node {
+  int val;
+  double prob;
+  
+  public Node(int val, double prob) {
+    this.val = val;
+    this.prob = prob;
+  }
+}

From 704b98bb443bc9b0f2942ecbe5e7023329697146 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 13 Jul 2020 10:51:30 -0500
Subject: [PATCH 0224/2175] Modified 2 solutions

---
 Easy/Same Tree.java                           | 29 ++++---
 .../Binary Tree Vertical Order Traversal.java | 81 ++++++++-----------
 2 files changed, 51 insertions(+), 59 deletions(-)

diff --git a/Easy/Same Tree.java b/Easy/Same Tree.java
index 603a65f7..b5d41af0 100644
--- a/Easy/Same Tree.java	
+++ b/Easy/Same Tree.java	
@@ -4,19 +4,26 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    
-    public boolean isSameTree(TreeNode p, TreeNode q) {
-        
-        if (p == null && q == null) return true;
-        if (p == null || q == null) return false;
-        
-        if (p.val == q.val) {
-            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
-        }
-        return false;   
+  public boolean isSameTree(TreeNode p, TreeNode q) {
+    if (p == null && q == null) {
+      return true;
     }
+    if (p == null || q == null) {
+      return false;
+    }
+    if (p.val != q.val) {
+      return false;
+    }
+    return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+  }
 }
diff --git a/Medium/Binary Tree Vertical Order Traversal.java b/Medium/Binary Tree Vertical Order Traversal.java
index bab9f0fc..93c1004a 100644
--- a/Medium/Binary Tree Vertical Order Traversal.java	
+++ b/Medium/Binary Tree Vertical Order Traversal.java	
@@ -4,62 +4,47 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    Map<Integer, List<Integer>> map = new TreeMap<>();
-    public List<List<Integer>> verticalOrder(TreeNode root) {
-        List<List<Integer>> ans = new ArrayList<>();
-        updateMap(root, 0);
-        
-        for (int key : map.keySet()) {
-            ans.add(map.get(key));
-        }
-        
-        return ans;
+  public List<List<Integer>> verticalOrder(TreeNode root) {
+    if (root == null) {
+      return new ArrayList<>();
     }
-    
-    private void updateMap(TreeNode root, int level) {
-        if (root == null) {
-            return;
+    Map<Integer, List<Integer>> map = new TreeMap<>();
+    Queue<TreeLevel> queue = new LinkedList<>();
+    queue.add(new TreeLevel(root, 0));
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeLevel removed = queue.remove();
+        map.computeIfAbsent(removed.level, k -> new ArrayList<>()).add(removed.node.val);
+        if (removed.node.left != null) {
+          queue.add(new TreeLevel(removed.node.left, removed.level - 1));
         }
-        
-        Queue<Element> queue = new LinkedList<>();
-        queue.add(new Element(root, 0));
-        
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            
-            while (size-- > 0) {
-                Element temp = queue.remove();
-                if (map.containsKey(temp.level)) {
-                    map.get(temp.level).add(temp.node.val);
-                }
-                else {
-                    List<Integer> list = new ArrayList<>();
-                    list.add(temp.node.val);
-                    map.put(temp.level, list);
-                }
-                
-                if (temp.node.left != null) {
-                    queue.add(new Element(temp.node.left, temp.level-1));
-                }
-                
-                if (temp.node.right != null) {
-                    queue.add(new Element(temp.node.right, temp.level+1));
-                }
-            }
+        if (removed.node.right != null) {
+          queue.add(new TreeLevel(removed.node.right, removed.level + 1));
         }
+      }
     }
+    return new ArrayList<>(map.values());
+  }
 }
 
-class Element {
-    public TreeNode node;
-    public int level;
 
-    public Element(TreeNode node, int level) {
-        this.node = node;
-        this.level = level;
-    }
+class TreeLevel {
+  TreeNode node;
+  int level;
+  
+  public TreeLevel(TreeNode node, int level) {
+    this.node = node;
+    this.level = level;
+  }
 }

From 9321707988e20820611e5764eaa0311af23244b2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 14 Jul 2020 10:23:39 -0500
Subject: [PATCH 0225/2175] Added 3 solutions

---
 Medium/Angle Between Hands of a Clock.java    |  8 ++++
 .../Check Completeness of a Binary Tree.java  | 41 +++++++++++++++++++
 Medium/Longest Arithmetic Sequence.java       | 16 ++++++++
 3 files changed, 65 insertions(+)
 create mode 100644 Medium/Angle Between Hands of a Clock.java
 create mode 100644 Medium/Check Completeness of a Binary Tree.java
 create mode 100644 Medium/Longest Arithmetic Sequence.java

diff --git a/Medium/Angle Between Hands of a Clock.java b/Medium/Angle Between Hands of a Clock.java
new file mode 100644
index 00000000..036ea3d8
--- /dev/null
+++ b/Medium/Angle Between Hands of a Clock.java	
@@ -0,0 +1,8 @@
+class Solution {
+  public double angleClock(int hour, int minutes) {
+    double angleByHourHand = (hour % 12 + minutes / 60.0) * 30;
+    double angleByMinuteHand = (double) 6 * minutes;
+    double diff = Math.abs(angleByHourHand - angleByMinuteHand);
+    return Math.min(diff, 360 - diff);
+  }
+}
diff --git a/Medium/Check Completeness of a Binary Tree.java b/Medium/Check Completeness of a Binary Tree.java
new file mode 100644
index 00000000..a0f1e5f5
--- /dev/null
+++ b/Medium/Check Completeness of a Binary Tree.java	
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public boolean isCompleteTree(TreeNode root) {
+    List<HelperNode> nodes = new ArrayList<>();
+    nodes.add(new HelperNode(root, 1));
+    int idx = 0 ;
+    while (idx < nodes.size()) {
+      HelperNode hnode = nodes.get(idx++);
+      if (hnode.node != null) {
+        nodes.add(new HelperNode(hnode.node.left, 2 * hnode.level));
+        nodes.add(new HelperNode(hnode.node.right, 2 * hnode.level + 1));
+      }
+    }
+    return nodes.get(idx - 1).level == nodes.size();
+  }
+}
+
+
+class HelperNode {
+  TreeNode node;
+  int level;
+  
+  public HelperNode(TreeNode node, int level) {
+    this.node = node;
+    this.level = level;
+  }
+}
diff --git a/Medium/Longest Arithmetic Sequence.java b/Medium/Longest Arithmetic Sequence.java
new file mode 100644
index 00000000..190f3d92
--- /dev/null
+++ b/Medium/Longest Arithmetic Sequence.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int longestArithSeqLength(int[] A) {
+    int res = 2;
+    int n = A.length;
+    HashMap<Integer, Integer>[] dp = new HashMap[n];
+    for (int j = 0; j < A.length; j++) {
+      dp[j] = new HashMap<>();
+      for (int i = 0; i < j; i++) {
+        int d = A[j] - A[i];
+        dp[j].put(d, dp[i].getOrDefault(d, 1) + 1);
+        res = Math.max(res, dp[j].get(d));
+      }
+    }
+    return res;
+  }
+}

From f250691fc78eb5d7c265db000e4bb76adabde0b6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 14 Jul 2020 16:33:30 -0500
Subject: [PATCH 0226/2175] Modified 6 solutions

---
 Easy/Max Area of Island.java             | 44 ++++++-----
 Easy/Minimum Depth of a Binary Tree.java | 41 ++++++++--
 Medium/Car Pooling.java                  | 37 +++++----
 Medium/Count Univalue Subtrees.java      | 57 +++++++-------
 Medium/Online Election.java              | 98 ++++++++++++------------
 Medium/Random Pick Index.java            | 28 ++++---
 6 files changed, 167 insertions(+), 138 deletions(-)

diff --git a/Easy/Max Area of Island.java b/Easy/Max Area of Island.java
index d8afa8fe..cfd4e66c 100644
--- a/Easy/Max Area of Island.java	
+++ b/Easy/Max Area of Island.java	
@@ -1,25 +1,27 @@
 class Solution {
-    int[][] grid;
-    boolean[][] seen;
-
-    public int area(int r, int c) {
-        if (r < 0 || r >= grid.length || c < 0 || c >= grid[0].length ||
-                seen[r][c] || grid[r][c] == 0)
-            return 0;
-        seen[r][c] = true;
-        return (1 + area(r+1, c) + area(r-1, c)
-                  + area(r, c-1) + area(r, c+1));
+  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public int maxAreaOfIsland(int[][] grid) {
+    int m = grid.length;
+    int n = grid[0].length;
+    int maxArea = 0;
+    boolean[][] visited = new boolean[m][n];
+    for (int i = 0; i < m; i++) {
+      for (int j = 0; j < n; j++) {
+        maxArea = Math.max(maxArea, helper(grid, i, j, m, n, visited));
+      }
     }
-
-    public int maxAreaOfIsland(int[][] grid) {
-        this.grid = grid;
-        seen = new boolean[grid.length][grid[0].length];
-        int ans = 0;
-        for (int r = 0; r < grid.length; r++) {
-            for (int c = 0; c < grid[0].length; c++) {
-                ans = Math.max(ans, area(r, c));
-            }
-        }
-        return ans;
+    return maxArea;
+  }
+  
+  private int helper(int[][] grid, int i, int j, int m, int n, boolean[][] visited) {
+    if (i < 0 || i >= m || j < 0 || j >= n || visited[i][j] || grid[i][j] == 0) {
+      return 0;
     }
+    int curr = 1;
+    visited[i][j] = true;
+    for (int[] dir : dirs) {
+      curr += helper(grid, i + dir[0], j + dir[1], m, n, visited);
+    }
+    return curr;
+  }
 }
diff --git a/Easy/Minimum Depth of a Binary Tree.java b/Easy/Minimum Depth of a Binary Tree.java
index e7edccd5..e1d21cc6 100644
--- a/Easy/Minimum Depth of a Binary Tree.java	
+++ b/Easy/Minimum Depth of a Binary Tree.java	
@@ -4,16 +4,41 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int minDepth(TreeNode root) {
-        if (root == null) return 0;
-        
-        int lDepth = minDepth(root.left);
-        int rDepth = minDepth(root.right);
-        
-        return (lDepth == 0 || rDepth == 0) ? lDepth + rDepth + 1 : Math.min(lDepth,rDepth) + 1;
+  public int minDepth(TreeNode root) {
+    if (root == null) {
+      return 0;
     }
+    int steps = 1;
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      // Level iteration
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        // Leaf reached
+        if (removed.left == null && removed.right == null) {
+          return steps;
+        }
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+      steps++;
+    }
+    return steps;
+  }
 }
diff --git a/Medium/Car Pooling.java b/Medium/Car Pooling.java
index 82c43aaa..ab96c443 100644
--- a/Medium/Car Pooling.java	
+++ b/Medium/Car Pooling.java	
@@ -1,22 +1,21 @@
 class Solution {
-    public boolean carPooling(int[][] trips, int capacity) {
-        PriorityQueue<Integer> end = new PriorityQueue<>(Comparator.comparingInt(o -> trips[o][2]));
-        Arrays.sort(trips, Comparator.comparingInt(o -> o[1]));
-        end.add(0);
-        int currCapacity = trips[0][0];
-        for (int i = 1; i < trips.length; i++) {
-            while (!end.isEmpty() && trips[i][1] >= trips[end.peek()][2]) {
-                currCapacity -= trips[end.poll()][0];
-            }
-
-            if (currCapacity + trips[i][0] > capacity) {
-                return false;
-            }
-
-            currCapacity += trips[i][0];
-            end.add(i);
-        }
-
-        return true;
+  public boolean carPooling(int[][] trips, int capacity) {
+    Arrays.sort(trips, Comparator.comparingInt(o -> o[1]));
+    int start = 0;
+    int idx = 0;
+    int n = trips.length;
+    int currCapacity = 0;
+    PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
+    while (idx < n) {
+      while (!pq.isEmpty() && pq.peek()[2] <= trips[idx][1]) {
+        currCapacity -= pq.poll()[0];
+      }
+      if (currCapacity + trips[idx][0] > capacity) {
+        return false;
+      }
+      currCapacity += trips[idx][0];
+      pq.add(trips[idx++]);
     }
+    return true;
+  }
 }
diff --git a/Medium/Count Univalue Subtrees.java b/Medium/Count Univalue Subtrees.java
index db729e21..2eae480a 100644
--- a/Medium/Count Univalue Subtrees.java	
+++ b/Medium/Count Univalue Subtrees.java	
@@ -4,37 +4,38 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    int count = 0;
-    public int countUnivalSubtrees(TreeNode root) {
-        updateCount(root);
-        return count;
+  public int countUnivalSubtrees(TreeNode root) {
+    int[] count = {0};
+    helper(root, count);
+    return count[0];
+  }
+  
+  private boolean helper(TreeNode root, int[] count) {
+    if (root == null) {
+      return true;
     }
-    
-    private void updateCount(TreeNode root) {
-        if (root == null) {
-            return;
-        }
-        
-        if (isUnivalue(root, root.val)) {
-            count++;
-        }
-        
-        updateCount(root.left);
-        updateCount(root.right);
-    }
-    
-    private boolean isUnivalue(TreeNode root, int val) {
-        if (root == null) {
-            return true;
-        }
-        if (root.val != val) {
-            return false;
-        }
-        
-        return isUnivalue(root.left, val) && isUnivalue(root.right, val);
+    boolean leftVal = helper(root.left, count);
+    boolean rightVal = helper(root.right, count);
+    if (leftVal && rightVal) {
+      if (
+        (root.left != null && root.left.val != root.val) || 
+        (root.right != null && root.right.val != root.val)
+      ) {
+        return false;
+      }
+      count[0]++;
+      return true;
     }
+    return false;
+  }
 }
diff --git a/Medium/Online Election.java b/Medium/Online Election.java
index 056879d5..34bc11ad 100644
--- a/Medium/Online Election.java	
+++ b/Medium/Online Election.java	
@@ -1,63 +1,59 @@
 class TopVotedCandidate {
 
-    Map<Integer, Integer> voteCount;
-    Map<Integer, Integer> timeCount;
-    int currLeaderCount;
-    List<Winner> winners;
-
-    public TopVotedCandidate(int[] persons, int[] times) {
-        voteCount = new HashMap<>();
-        timeCount = new HashMap<>();
-        currLeaderCount = 0;
-        winners = new ArrayList<>();
-        
-        for (int i = 0; i < persons.length; i++) {
-            boolean isPresent = voteCount.containsKey(persons[i]);
-            voteCount.put(persons[i], voteCount.getOrDefault(persons[i], 0) + 1);
-            timeCount.put(persons[i], times[i]);
-            if (voteCount.get(persons[i]) >= currLeaderCount) {
-                winners.add(new Winner(persons[i], times[i]));
-                currLeaderCount = Math.max(currLeaderCount, voteCount.get(persons[i]));
-            }
-        }
-    }
-
-    public int q(int t) {
-        return winners.get(binarySearchHelper(winners, 0, winners.size() - 1, t)).val;
+  List<Winner> winners;
+  public TopVotedCandidate(int[] persons, int[] times) {
+    winners = new ArrayList<>();
+    Map<Integer, Integer> countMap = new HashMap<>();
+    Map<Integer, Integer> timeMap = new HashMap<>();
+    int maxVotes = 0;
+    for (int i = 0; i < persons.length; i++) {
+      countMap.put(persons[i], countMap.getOrDefault(persons[i], 0) + 1);
+      timeMap.put(persons[i], times[i]);
+      if (countMap.get(persons[i]) >= maxVotes) {
+        winners.add(new Winner(times[i], persons[i]));
+        maxVotes = Math.max(maxVotes, countMap.get(persons[i]));
+      }
     }
+  }
 
-    private int binarySearchHelper(List<Winner> winners, int left, int right, int target) {
-        int idx = winners.size();
-        while (left <= right) {
-            int mid = (left + right) / 2;
-            if (winners.get(mid).time == target) {
-                idx = mid;
-                break;
-            }
-            else if (winners.get(mid).time < target) {
-                idx = mid;
-                left = mid + 1;
-            }
-            else {
-                right = mid - 1;
-            }
-        }
-        
-        return idx == winners.size() ? 0 : idx;
+  public int q(int t) {
+    return winners.get(binarySearchHelper(t)).val;
+  }
+  
+  private int binarySearchHelper(int target) {
+    int start = 0;
+    int end = winners.size() - 1;
+    int idx = 0;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (winners.get(mid).time == target) {
+        idx = mid;
+        break;
+      }
+      else if (winners.get(mid).time < target) {  
+        idx = mid;
+        start = mid + 1;
+      }
+      else {
+        end = mid - 1;
+      }
     }
+    return idx == winners.size() ? 0 : idx;
+  }
 }
 
-class Winner {
-    int val;
-    int time;
-
-    public Winner(int val, int time) {
-        this.val = val;
-        this.time = time;
-    }
-}
 /**
  * Your TopVotedCandidate object will be instantiated and called as such:
  * TopVotedCandidate obj = new TopVotedCandidate(persons, times);
  * int param_1 = obj.q(t);
  */
+
+class Winner {
+  int time;
+  int val;
+  
+  public Winner(int time, int val) {
+    this.time = time;
+    this.val = val;
+  }
+}
diff --git a/Medium/Random Pick Index.java b/Medium/Random Pick Index.java
index 4906e1de..e6ac8299 100644
--- a/Medium/Random Pick Index.java	
+++ b/Medium/Random Pick Index.java	
@@ -1,17 +1,23 @@
 class Solution {
-    Map<Integer, List<Integer>> map = new HashMap();
-    Random rand;
-    public Solution(int[] nums) {
-        rand = new Random();
-        for (int i = 0; i < nums.length; i++) {
-            map.computeIfAbsent(nums[i], k -> new ArrayList<>()).add(i);
+  int[] nums;
+  Random rand;
+  public Solution(int[] nums) {
+    this.nums = nums;
+    rand = new Random();
+  }
+
+  public int pick(int target) {
+    int count = 0;
+    int res = 0;
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] == target) {
+        if (rand.nextInt(++count) == 0) {
+          res = i;
         }
+      }
     }
-    
-    public int pick(int target) {
-        List<Integer> indexes = map.get(target);
-        return indexes.get(rand.nextInt(indexes.size()));
-    }
+    return res;
+  }
 }
 
 /**

From 0005e756f1e3baef9e758afd9f13687ade4a0c5f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 15 Jul 2020 09:45:31 -0500
Subject: [PATCH 0227/2175] Modified 8 solutions

---
 Easy/Find Pivot Index.java                    | 32 ++++----
 Easy/Maximum Product of three numbers.java    | 82 ++-----------------
 Easy/Ransom Note.java                         | 14 ++--
 ...t Position of Element in Sorted Array.java | 78 ++++++------------
 Medium/Flatten Nested List Iterator.java      | 66 +++++++++------
 Medium/Linked List Random Node.java           | 59 ++++++-------
 Medium/Reverse Words in a String.java         | 48 +++++------
 Medium/Top K Frequent Words.java              | 45 +++++-----
 8 files changed, 159 insertions(+), 265 deletions(-)

diff --git a/Easy/Find Pivot Index.java b/Easy/Find Pivot Index.java
index 9965ed44..0bc7b234 100644
--- a/Easy/Find Pivot Index.java	
+++ b/Easy/Find Pivot Index.java	
@@ -1,21 +1,17 @@
 class Solution {
-    public int pivotIndex(int[] nums) {
-        int left = 0;
-        int sum = 0;
-        
-        for (int i=0;i<nums.length;i++) {
-            sum += nums[i];
-        }
-        
-        for (int i=0;i<nums.length;i++) {
-            if (i != 0) {
-                left += nums[i-1];
-            }
-            if (sum - left - nums[i] == left) {
-                return i;
-            }
-        }
-        
-        return -1;
+  public int pivotIndex(int[] nums) {
+    int n = nums.length;
+    int sum = 0;
+    for (int i = 0; i < n; i++) {
+      sum += nums[i];
     }
+    int leftSum = 0;
+    for (int i = 0; i < n; i++) {
+      if (leftSum == sum - leftSum - nums[i]) {
+        return i;
+      }
+      leftSum += nums[i];
+    }
+    return -1;
+  }
 }
diff --git a/Easy/Maximum Product of three numbers.java b/Easy/Maximum Product of three numbers.java
index 0f183fcd..ebc6f79b 100644
--- a/Easy/Maximum Product of three numbers.java	
+++ b/Easy/Maximum Product of three numbers.java	
@@ -1,76 +1,10 @@
 class Solution {
-    public int maximumProduct(int[] nums) {
-        int max1 = Integer.MIN_VALUE;
-        int max2 = Integer.MIN_VALUE;
-        int max3 = Integer.MIN_VALUE;
-        int min1 = Integer.MAX_VALUE;
-        int min2 = Integer.MAX_VALUE;
-        
-        for (int num : nums) {
-            if (max1 == Integer.MIN_VALUE) {
-                max1 = num;
-            }
-            else if (max2 == Integer.MIN_VALUE) {
-                if (num > max1) {
-                    max2 = max1;
-                    max1 = num;
-                }
-                else {
-                    max2 = num;
-                }
-            }
-            else if (max3 == Integer.MIN_VALUE) {
-                if (num > max1) {
-                    max3 = max2;
-                    max2 = max1;
-                    max1 = num;
-                }
-                else if (num > max2) {
-                    max3 = max2;
-                    max2 = num;
-                }
-                else {
-                    max3 = num;
-                }
-            }
-            else {
-                if (num > max1) {
-                    max3 = max2;
-                    max2 = max1;
-                    max1 = num;
-                }
-                else if (num > max2) {
-                    max3 = max2;
-                    max2 = num;
-                }
-                else {
-                    max3 = Math.max(max3, num);
-                }
-            }
-            
-            if (min1 == Integer.MIN_VALUE) {
-                min1 = num;
-            }
-            else if (min2 == Integer.MIN_VALUE) {
-                if (min1 > num) {
-                    min2 = min1;
-                    min1 = num;
-                }
-                else {
-                    min2 = num;
-                }
-            }
-            else {
-                if (min1 > num) {
-                    min2 = min1;
-                    min1 = num;
-                }
-                else {
-                    min2 = Math.min(min2, num);
-                }
-            }
-        }
-        
-        return Math.max(min1 * min2 * max1, max1 * max2 * max3);
-    }
+  public int maximumProduct(int[] nums) {
+    Arrays.sort(nums);
+    int n = nums.length;
+    int rightSideProd = nums[n - 1] * nums[n - 2] * nums[n - 3];
+    int leftSideProd = nums[0] * nums[1] * nums[2];
+    int mixedSideProd = nums[0] * nums[1] * nums[n - 1];
+    return Math.max(rightSideProd, Math.max(leftSideProd, mixedSideProd));
+  }
 }
diff --git a/Easy/Ransom Note.java b/Easy/Ransom Note.java
index f302bc31..21a532c5 100644
--- a/Easy/Ransom Note.java	
+++ b/Easy/Ransom Note.java	
@@ -1,17 +1,15 @@
 class Solution {
   public boolean canConstruct(String ransomNote, String magazine) {
-    int[] counter = new int[26];
-    for (char c : ransomNote.toCharArray()) {
-      counter[c - 'a']++;
-    }
+    int[] count = new int[26];
     for (char c : magazine.toCharArray()) {
-      counter[c - 'a']--;
+      count[c - 'a']++;
     }
-    for (int i = 0; i < 26; i++) {
-      if (counter[i] > 0) {
+    for (char c: ransomNote.toCharArray()) {
+      if (count[c - 'a'] == 0) {
         return false;
       }
+      count[c - 'a']--;
     }
     return true;
-  } 
+  }
 }
diff --git a/Medium/Find First and Last Position of Element in Sorted Array.java b/Medium/Find First and Last Position of Element in Sorted Array.java
index 18909848..2d9e263a 100644
--- a/Medium/Find First and Last Position of Element in Sorted Array.java	
+++ b/Medium/Find First and Last Position of Element in Sorted Array.java	
@@ -1,58 +1,30 @@
 class Solution {
-    public int[] searchRange(int[] nums, int target) {
-        int idx = findBinary(nums, 0, nums.length-1, target);
-        int startIdx = idx;
-        int endIdx = idx;
-        
-        int start = 0;
-        int end = idx - 1;
-        
-        while (true) {
-            int temp = findBinary(nums, start, end, target);
-            if (temp != -1) {
-                startIdx = temp;
-                start = 0;
-                end = temp - 1;
-            }
-            else {
-                break;
-            }
+  public int[] searchRange(int[] nums, int target) {
+    return new int[]{binarySearchHelper(nums, target, -1), binarySearchHelper(nums, target, 1)};
+  } 
+  
+  private int binarySearchHelper(int[] nums, int target, int dir) {
+    int start = 0;
+    int end = nums.length - 1;
+    int idx = -1;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (nums[mid] == target) {
+        idx = mid;
+        if (dir == -1) {
+          end = mid - 1;
         }
-        
-        start = idx + 1;
-        end = nums.length - 1;
-        
-        while (true) {
-            int temp = findBinary(nums, start, end, target);
-            if (temp != -1) {
-                endIdx = temp;
-                start = temp + 1;
-                end = nums.length - 1;
-            }
-            else {
-                break;
-            }
+        else {
+          start = mid + 1;
         }
-        
-        int[] ans = new int[]{startIdx, endIdx};
-            
-        return ans;
-    }
-    
-    private int findBinary(int[] nums, int start, int end, int target) {
-        while (start <= end) {
-            int mid = (start + end)/2;
-            if (nums[mid] == target) {
-                return mid;
-            }
-            else if (nums[mid] > target) {
-                end = mid-1;
-            }
-            else {
-                start = mid + 1;
-            }
-        }
-        
-        return -1;
+      }
+      else if (nums[mid] < target) {
+        start = mid + 1;
+      }
+      else {
+        end = mid - 1;
+      }
     }
+    return idx;
+  }
 }
diff --git a/Medium/Flatten Nested List Iterator.java b/Medium/Flatten Nested List Iterator.java
index a4253545..0a54bc02 100644
--- a/Medium/Flatten Nested List Iterator.java	
+++ b/Medium/Flatten Nested List Iterator.java	
@@ -16,36 +16,48 @@
  * }
  */
 public class NestedIterator implements Iterator<Integer> {
-    
-    Stack<NestedInteger> stack;
-    public NestedIterator(List<NestedInteger> nestedList) {
-        stack = new Stack<>();
-        for (int i = nestedList.size() - 1; i >= 0; i--) {
-            stack.push(nestedList.get(i));
-        }
-    }
+  List<NestedInteger> nestedList;
+  Queue<Integer> queue;
+  int idx;
+  public NestedIterator(List<NestedInteger> nestedList) {
+    this.nestedList = nestedList;
+    queue = new LinkedList<>();
+    idx = 0;
+    addToQueue();
+  }
 
-    @Override
-    public Integer next() {
-        return stack.pop().getInteger();
+  @Override
+  public Integer next() {
+    int val = queue.remove();
+    if (queue.isEmpty()) {
+      if (idx != nestedList.size()) {
+        addToQueue();
+      }
     }
-
-    @Override
-    public boolean hasNext() {
-        while (!stack.isEmpty()) {
-            NestedInteger curr = stack.peek();
-            if (curr.isInteger()) {
-                return true;
-            }
-            
-            NestedInteger temp = stack.pop();
-            for (int i = temp.getList().size() - 1; i >= 0; i--) {
-                stack.push(temp.getList().get(i));
-            }
-        }
-        
-        return false;
+    return val;
+  }
+  
+  private void addToQueue() {
+    while (idx < nestedList.size() && queue.isEmpty()) {
+      addToQueueHelper(nestedList.get(idx++));
+    }
+  }
+  
+  private void addToQueueHelper(NestedInteger ns) {
+    if (ns.isInteger()) {
+      queue.add(ns.getInteger());
     }
+    else {
+      for (NestedInteger ni : ns.getList()) {
+        addToQueueHelper(ni);
+      }
+    }
+  }
+
+  @Override
+  public boolean hasNext() {
+    return !(queue.isEmpty() && idx == nestedList.size());
+  }
 }
 
 /**
diff --git a/Medium/Linked List Random Node.java b/Medium/Linked List Random Node.java
index f29d4831..2e89913a 100644
--- a/Medium/Linked List Random Node.java	
+++ b/Medium/Linked List Random Node.java	
@@ -3,47 +3,34 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
 
-    /** @param head The linked list's head.
-        Note that the head is guaranteed to be not null, so it contains at least one node. */
-    ListNode head;
-    int length;
-    public Solution(ListNode head) {
-        this.head = head;
-        length = findLength(head);
-    }
-    
-    private int findLength(ListNode head) {
-        int count = 0;
-        
-        while (head != null) {
-            count++;
-            head = head.next;
-        }
-        
-        return count;
-    }
-    
-    /** Returns a random node's value. */
-    public int getRandom() {
-        int idx = new Random().nextInt(((length - 1) - 0) + 1);
-        return getKthNode(head, idx);
-    }
-    
-    private int getKthNode(ListNode head, int k) {
-        int count = 0;
-        
-        while (count < k) {
-            count++;
-            head = head.next;
-        }
-        
-        return head.val;
+  /** @param head The linked list's head.
+      Note that the head is guaranteed to be not null, so it contains at least one node. */
+  ListNode head;
+  Random rand;
+  public Solution(ListNode head) {
+    this.head = head;
+    rand = new Random();
+  }
+
+  /** Returns a random node's value. */
+  public int getRandom() {
+    ListNode curr = head;
+    int val = curr.val;
+    for (int i = 1; curr.next != null; i++) {
+      curr = curr.next;
+      if (rand.nextInt(i + 1) == i) {
+        val = curr.val;
+      }
     }
+    return val;
+  }
 }
 
 /**
diff --git a/Medium/Reverse Words in a String.java b/Medium/Reverse Words in a String.java
index 92e4ffcd..491b3d51 100644
--- a/Medium/Reverse Words in a String.java	
+++ b/Medium/Reverse Words in a String.java	
@@ -1,26 +1,28 @@
-public class Solution {
-    public String reverseWords(String s) {
-        StringBuilder sb = new StringBuilder();
-        int i = s.length() - 1;
-        StringBuilder temp = new StringBuilder();
-        while (i >= 0) {
-            if (s.charAt(i) != ' ') {
-                while (i >= 0 && s.charAt(i) != ' ') {
-                    temp.append(s.charAt(i));
-                    i--;
-                }
-
-                sb.append(temp.reverse().toString()).append(" ");
-                temp = new StringBuilder();
-            }
-
-            i--;
+class Solution {
+  public String reverseWords(String s) {
+    Stack<String> stack = new Stack<>();
+    StringBuilder sb = new StringBuilder();
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      if (s.charAt(idx) != ' ') {
+        sb.append(s.charAt(idx));
+      }
+      if (s.charAt(idx) == ' ' || idx == n - 1) {
+        if (sb.length() > 0) {
+          stack.push(sb.toString());
+          sb.setLength(0);
         }
-
-        if (temp.length() > 0) {
-            sb.append(temp.reverse().toString());
-        }
-
-        return sb.toString().trim();
+      }
+      idx++;
+    }
+    sb.setLength(0);
+    while (!stack.isEmpty()) {
+      sb.append(stack.pop());
+      if (!stack.isEmpty()) {
+        sb.append(" ");
+      }
     }
+    return sb.toString();
+  }
 }
diff --git a/Medium/Top K Frequent Words.java b/Medium/Top K Frequent Words.java
index 5b26e158..50a3911f 100644
--- a/Medium/Top K Frequent Words.java	
+++ b/Medium/Top K Frequent Words.java	
@@ -1,30 +1,23 @@
 class Solution {
-    public List<String> topKFrequent(String[] words, int k) {
-        Map<String, Integer> map = new HashMap<>();
-        for (String word : words) {
-            map.put(word, map.getOrDefault(word, 0) + 1);
-        }
-        
-        PriorityQueue<String> pq = new PriorityQueue<>(new Comparator<String>(){
-            public int compare(String s1, String s2) {
-                int c = map.get(s2).compareTo(map.get(s1));
-                if (c != 0) {
-                    return c;
-                }
-                
-                return s1.compareTo(s2);
-            } 
-        });
-        
-        for (String key : map.keySet()) {
-            pq.add(key);
-        }
-        
-        List<String> list = new ArrayList<>();
-        while (k-- > 0 && !pq.isEmpty()) {
-            list.add(pq.poll());
+  public List<String> topKFrequent(String[] words, int k) {
+    Map<String, Integer> map = new HashMap<>();
+    for (String word : words) {
+      map.put(word, map.getOrDefault(word, 0) + 1);
+    }
+    PriorityQueue<String> pq = new PriorityQueue<>(new Comparator<String>(){
+      public int compare(String s1, String s2) {
+        int c = map.get(s2) - map.get(s1);
+        if (c != 0) {
+          return c;
         }
-        
-        return list;
+        return s1.compareTo(s2);
+      }
+    });
+    pq.addAll(map.keySet());
+    List<String> ans = new ArrayList<>();
+    while (!pq.isEmpty() && k-- > 0) {
+      ans.add(pq.poll());
     }
+    return ans;
+  }
 }

From 597c4ab5e538ce6c44465e8d842d99150c32e6e4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 15 Jul 2020 18:09:55 -0500
Subject: [PATCH 0228/2175] Modified 4 solutions

---
 Easy/Longest Harmonious Subsequence.java | 29 +++++++++-------------
 Easy/Palindrome Permutation.java         | 10 ++++----
 Medium/Search a 2D Matrix.java           | 21 ++++++++++------
 Medium/Subarray Sums Divisible by K.java | 31 +++++++++++-------------
 4 files changed, 44 insertions(+), 47 deletions(-)

diff --git a/Easy/Longest Harmonious Subsequence.java b/Easy/Longest Harmonious Subsequence.java
index 98729d86..cd052aa8 100644
--- a/Easy/Longest Harmonious Subsequence.java	
+++ b/Easy/Longest Harmonious Subsequence.java	
@@ -1,20 +1,15 @@
 class Solution {
-    public int findLHS(int[] nums) {
-        
-        int max = 0;
-        
-        Map<Integer, Integer> map = new HashMap<>();
-        
-        for (int n : nums) {
-            map.put(n, map.getOrDefault(n,0)+1);
-        }
-        
-        for (int key : map.keySet()) {
-            if (map.containsKey(key+1)) {
-                max = Math.max(max, map.get(key) + map.get(key+1));
-            }
-        }
-        
-        return max;
+  public int findLHS(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
     }
+    int res = 0;
+    for (Integer key : map.keySet()) {
+      if (map.containsKey(key + 1)) {
+        res = Math.max(res, map.get(key) + map.get(key + 1));
+      }
+    }
+    return res;
+  }
 }
diff --git a/Easy/Palindrome Permutation.java b/Easy/Palindrome Permutation.java
index 5397212d..f1d5b084 100644
--- a/Easy/Palindrome Permutation.java	
+++ b/Easy/Palindrome Permutation.java	
@@ -1,13 +1,13 @@
 class Solution {
   public boolean canPermutePalindrome(String s) {
-    Map<Character, Integer> map = new HashMap<>();
+    int[] count = new int[256];
     for (char c : s.toCharArray()) {
-      map.put(c, map.getOrDefault(c, 0) + 1);
+      count[(int) c]++;
     }
     boolean oddFound = false;
-    for (Character key : map.keySet()) {
-      if (map.get(key) % 2 != 0) {
-        if (oddFound) {
+    for (int i = 0; i < 256; i++) {
+      if (count[i] % 2 != 0) {
+        if (s.length() % 2 == 0 || oddFound) {
           return false;
         }
         oddFound = true;
diff --git a/Medium/Search a 2D Matrix.java b/Medium/Search a 2D Matrix.java
index 7375d4f3..18236db6 100644
--- a/Medium/Search a 2D Matrix.java	
+++ b/Medium/Search a 2D Matrix.java	
@@ -3,17 +3,22 @@ public boolean searchMatrix(int[][] matrix, int target) {
     if (matrix.length == 0 || matrix[0].length == 0) {
       return false;
     }
-    int row = matrix.length - 1;
-    int col = 0;
-    while (row >= 0 && col < matrix[0].length) {
-      if (matrix[row][col] == target) {
+    int i = 0;
+    int j = 0;
+    int rows = matrix.length;
+    int cols = matrix[0].length;
+    while (i < rows && j < cols) {
+      int num = matrix[i][j];
+      if (num == target) {
         return true;
       }
-      else if (matrix[row][col] > target) {
-        row--;
-      }
       else {
-        col++;
+        if (i != rows - 1 && matrix[i + 1][j] <= target) {
+          i++;
+        }
+        else {
+          j++;
+        }
       }
     }
     return false;
diff --git a/Medium/Subarray Sums Divisible by K.java b/Medium/Subarray Sums Divisible by K.java
index de3edc30..46033b44 100644
--- a/Medium/Subarray Sums Divisible by K.java	
+++ b/Medium/Subarray Sums Divisible by K.java	
@@ -1,20 +1,17 @@
 class Solution {
-    public int subarraysDivByK(int[] A, int K) {
-        int count = 0;
-        int sum = 0;
-        Map<Integer, Integer> map = new HashMap<>();
-        map.put(0, 1);
-        
-        for (int i = 0; i < A.length; i++) {
-            sum = (sum + A[i]) % K;
-            if (sum < 0) {
-                sum += K;
-            }
-            
-            count += map.getOrDefault(sum, 0);
-            map.put(sum, map.getOrDefault(sum, 0) + 1);
-        }
-        
-        return count;
+  public int subarraysDivByK(int[] A, int K) {
+    int sum = 0;
+    int count = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    map.put(0, 1);
+    for (int i = 0; i < A.length; i++) {
+      sum = (sum + A[i]) % K;
+      if (sum < 0) {
+        sum += K;
+      }
+      count += map.getOrDefault(sum, 0);
+      map.put(sum, map.getOrDefault(sum, 0) + 1);
     }
+    return count;
+  }
 }

From 764962da7fd28da8094e869aa76a15d922bf652e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 16 Jul 2020 09:20:43 -0500
Subject: [PATCH 0229/2175] Modified 4 solutions

---
 Medium/Bulb Switcher.java                 |  6 ++--
 Medium/Kth Smallest Element in a BST.java | 41 +++++++++++------------
 Medium/Pow.java                           | 17 ++++++++--
 Medium/Reconstruct Itinerary.java         | 28 +++++++---------
 4 files changed, 51 insertions(+), 41 deletions(-)

diff --git a/Medium/Bulb Switcher.java b/Medium/Bulb Switcher.java
index 1d9b580e..fe756a18 100644
--- a/Medium/Bulb Switcher.java	
+++ b/Medium/Bulb Switcher.java	
@@ -1,5 +1,5 @@
 class Solution {
-    public int bulbSwitch(int n) {
-        return (int)Math.sqrt(n);
-    }
+  public int bulbSwitch(int n) {
+    return (int) Math.sqrt(n);
+  }
 }
diff --git a/Medium/Kth Smallest Element in a BST.java b/Medium/Kth Smallest Element in a BST.java
index afb379f1..74cb3112 100644
--- a/Medium/Kth Smallest Element in a BST.java	
+++ b/Medium/Kth Smallest Element in a BST.java	
@@ -4,29 +4,28 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int kthSmallest(TreeNode root, int k) {
-        Stack<TreeNode> stack = new Stack<>();
-        
-        while (root != null || !stack.empty()) {
-            while (root != null) {
-                stack.push(root);
-                root = root.left;
-            }
-            
-            root = stack.peek();
-            stack.pop();
-            
-            if (--k == 0) {
-                return root.val;
-            }
-            
-            root = root.right;
-        }
-        
-        return -1;
+  public int kthSmallest(TreeNode root, int k) {
+    Stack<TreeNode> stack = new Stack<>();
+    while (true) {
+      while (root != null) {
+        stack.push(root);
+        root = root.left;
+      }
+      root = stack.pop();
+      if (--k == 0) {
+        return root.val;
+      }
+      root = root.right;
     }
+  }
 }
diff --git a/Medium/Pow.java b/Medium/Pow.java
index d27486cf..8278dc37 100644
--- a/Medium/Pow.java
+++ b/Medium/Pow.java
@@ -1,5 +1,18 @@
 class Solution {
-    public double myPow(double x, int n) {
-        return Math.pow(x,n);
+  public double myPow(double x, int n) {
+    long N = n;
+    if (N < 0) {
+      x = 1 / x;
+      N = -N;
     }
+    double ans = 1;
+    double currProd = x;
+    for (long i = N; i > 0; i /= 2) {
+      if ((i % 2) == 1) {
+        ans = ans * currProd;
+      }
+      currProd = currProd * currProd;
+    }
+    return ans;
+  }
 }
diff --git a/Medium/Reconstruct Itinerary.java b/Medium/Reconstruct Itinerary.java
index 68d6598b..7951bfc3 100644
--- a/Medium/Reconstruct Itinerary.java	
+++ b/Medium/Reconstruct Itinerary.java	
@@ -2,24 +2,24 @@ class Solution {
   List<String> result = null;
   public List<String> findItinerary(List<List<String>> tickets) {
     Map<String, List<String>> map = new HashMap<>();
-    Map<String, boolean[]> visitMap = new HashMap<>();
     int flights = tickets.size();
     for (List<String> ticket : tickets) {
       map.computeIfAbsent(ticket.get(0), k -> new ArrayList<>()).add(ticket.get(1));
     }
+    Map<String, boolean[]> visited = new HashMap<>();
     for (Map.Entry<String, List<String>> entry : map.entrySet()) {
       Collections.sort(entry.getValue());
-      visitMap.put(entry.getKey(), new boolean[entry.getValue().size()]);
+      visited.put(entry.getKey(), new boolean[entry.getValue().size()]);
     }
     LinkedList<String> route = new LinkedList<String>();
     route.add("JFK");
-    backtrack(map, visitMap, flights, route, "JFK");
+    backtrack(map, visited, flights, route, "JFK");
     return result;
   }
   
   private boolean backtrack(
     Map<String, List<String>> map,
-    Map<String, boolean[]> visitMap,
+    Map<String, boolean[]> visited,
     int flights,
     LinkedList<String> route,
     String origin
@@ -31,20 +31,18 @@ private boolean backtrack(
     if (!map.containsKey(origin)) {
       return false;
     }
-    int i = 0;
-    boolean[] visited = visitMap.get(origin);
-    for (String dest : map.get(origin)) {
-      if (!visited[i]) {
-        visited[i] = true;
-        route.add(dest);
-        boolean res = backtrack(map, visitMap, flights, route, dest);
+    boolean[] visit = visited.get(origin);
+    for (int i = 0; i < map.get(origin).size(); i++) {
+      if (!visit[i]) {
+        visit[i] = true;
+        route.add(map.get(origin).get(i));
+        boolean res = backtrack(map, visited, flights, route, map.get(origin).get(i));
         route.pollLast();
-        visited[i] = false;
-        if (res == true) {
-          return true;
+        visit[i] = false;
+        if (res) {
+          return res;
         }
       }
-      i++;
     }
     return false;
   }

From a127e2bbf604c9daf95c847c7e1dafab4a740d6d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 16 Jul 2020 17:25:23 -0500
Subject: [PATCH 0230/2175] Added 2 solutions & modified 3 solutions

---
 Easy/Index Pairs of a String.java             |  50 ++++++++
 Easy/Magic Squares In Grid.java               |  85 +++++++-------
 .../Can Make Palindrome from Substring.java   |  18 +++
 Medium/Clone Graph.java                       |  52 ++++----
 Medium/Reorder List.java                      | 111 ++++++------------
 5 files changed, 176 insertions(+), 140 deletions(-)
 create mode 100644 Easy/Index Pairs of a String.java
 create mode 100644 Medium/Can Make Palindrome from Substring.java

diff --git a/Easy/Index Pairs of a String.java b/Easy/Index Pairs of a String.java
new file mode 100644
index 00000000..97d590ce
--- /dev/null
+++ b/Easy/Index Pairs of a String.java	
@@ -0,0 +1,50 @@
+class Solution {
+  public int[][] indexPairs(String text, String[] words) {
+    TrieNode root = new TrieNode('-');
+    for (String word : words) {
+      addWord(word, root);
+    }
+    List<int[]> list = new ArrayList<>();
+    for (int i = 0; i < text.length(); i++) {
+      int j = i;
+      TrieNode curr = root;
+      while (j < text.length() && curr.childrens.containsKey(text.charAt(j))) {
+        curr = curr.childrens.get(text.charAt(j));
+        if (curr.isWord) {
+          list.add(new int[]{i, j});
+        }
+        j++;
+      }
+    }
+    int[][] ans = new int[list.size()][2];
+    for (int i = 0; i < list.size(); i++) {
+      ans[i] = list.get(i);
+    }
+    return ans;
+  }
+  
+  private void addWord(String s, TrieNode root) {
+    for (int i = 0; i < s.length(); i++) {
+      if (!root.childrens.containsKey(s.charAt(i))) {
+        root.childrens.put(s.charAt(i), new TrieNode(s.charAt(i)));
+      }
+      root = root.childrens.get(s.charAt(i));
+      if (i == s.length() - 1) {
+        root.isWord = true;
+      }
+    }
+  }
+}
+
+
+class TrieNode {
+  char c;
+  Map<Character, TrieNode> childrens;
+  boolean isWord;
+  
+  public TrieNode(char c) {
+    this.c = c;
+    childrens = new HashMap<>();
+    isWord = false;
+  }
+}
diff --git a/Easy/Magic Squares In Grid.java b/Easy/Magic Squares In Grid.java
index 1ec774c5..fea5b550 100644
--- a/Easy/Magic Squares In Grid.java	
+++ b/Easy/Magic Squares In Grid.java	
@@ -1,49 +1,46 @@
 class Solution {
-    public int numMagicSquaresInside(int[][] grid) {
-        int rows = grid.length;
-        int col = grid[0].length;
-        int count = 0;
-
-        for (int i=0; i<=rows-3; i++) {
-            for (int j=0; j<=col-3; j++) {
-                if(checker(i, j, grid)) {
-                    count++;
-                }
-            }
+  public int numMagicSquaresInside(int[][] grid) {
+    int rows = grid.length; 
+    int cols = grid[0].length;
+    int count = 0;
+    for (int i = 0; i < rows - 2; i++) {
+      for (int j = 0; j < cols - 2; j++) {
+        if (grid[i + 1][j + 1] != 5) {
+          continue;
         }
-
-        return count;
-    }
-
-    private boolean checker(int x,int y,int[][] grid){
-        if(grid[x+1][y+1]!=5) {
-            return false;
-        }
-
-        int[] valid=new int[16];
-
-        for(int i=x;i<=x+2;i++) {
-            for(int j=y;j<=y+2;j++) {
-                valid[grid[i][j]]++;
-            }
-        }
-
-        for (int v = 1; v <= 9; v++) {
-            if (valid[v] != 1) {
-                return false;
-            }
+        if (
+          magic(
+            grid[i][j], grid[i][j + 1], grid[i][j + 2],
+            grid[i + 1][j], grid[i + 1][j + 1], grid[i + 1][j + 2],
+            grid[i + 2][j], grid[i + 2][j + 1], grid[i + 2][j + 2]
+          )
+        ) {
+          count++;
         }
-
-        if ((grid[x][y]+grid[x][y+1]+grid[x][y+2])!=15 ||
-            (grid[x][y]+grid[x+1][y+1]+grid[x+2][y+2])!=15 ||
-            (grid[x][y]+grid[x+1][y]+grid[x+2][y])!=15 ||
-            (grid[x+2][y]+grid[x+2][y+1]+grid[x+2][y+2])!=15 ||
-            (grid[x][y+2]+grid[x+1][y+2]+grid[x+2][y+2])!=15 ||
-            (grid[x][y+2]+grid[x+1][y+1]+grid[x+2][y])!=15) {
-            
-            return false;
-        }
-        
-        return true;
+      }
+    }
+    return count;
+  }
+  
+  private boolean magic(int... vals) {
+    int[] count = new int[16];
+    for (int v : vals) {
+      count[v]++;
+    }
+    for (int v = 1; v <= 9; v++) {
+      if (count[v] != 1) {
+        return false;
+      }
     }
+    return (
+      vals[0] + vals[1] + vals[2] == 15 &&
+      vals[3] + vals[4] + vals[5] == 15 &&
+      vals[6] + vals[7] + vals[8] == 15 &&
+      vals[0] + vals[3] + vals[6] == 15 &&
+      vals[1] + vals[4] + vals[7] == 15 &&
+      vals[2] + vals[5] + vals[8] == 15 &&
+      vals[0] + vals[4] + vals[8] == 15 &&
+      vals[2] + vals[4] + vals[6] == 15
+    );
+  }
 }
diff --git a/Medium/Can Make Palindrome from Substring.java b/Medium/Can Make Palindrome from Substring.java
new file mode 100644
index 00000000..3640e74f
--- /dev/null
+++ b/Medium/Can Make Palindrome from Substring.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
+    int[][] count = new int[s.length() + 1][26];
+    for (int i = 0; i < s.length(); i++) {
+      count[i + 1] = count[i].clone();
+      count[i + 1][s.charAt(i) - 'a']++;
+    }
+    List<Boolean> list = new ArrayList<>();
+    for (int[] query : queries) {
+      int sum = 0;
+      for (int i = 0; i < 26; i++) {
+        sum += (count[query[1] + 1][i] - count[query[0]][i]) % 2;
+      }
+      list.add(sum / 2 <= query[2]);
+    }
+    return list;
+  }
+}
diff --git a/Medium/Clone Graph.java b/Medium/Clone Graph.java
index 02c97aee..1c116288 100644
--- a/Medium/Clone Graph.java	
+++ b/Medium/Clone Graph.java	
@@ -3,33 +3,43 @@
 class Node {
     public int val;
     public List<Node> neighbors;
-
-    public Node() {}
-
-    public Node(int _val,List<Node> _neighbors) {
+    
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    
+    public Node(int _val, ArrayList<Node> _neighbors) {
         val = _val;
         neighbors = _neighbors;
     }
-};
+}
 */
+
 class Solution {
+  public Node cloneGraph(Node node) {
+    if (node == null) {
+      return null;
+    }
     Map<Node, Node> map = new HashMap<>();
-    public Node cloneGraph(Node node) {
-        if (node == null) {
-            return null;
-        }
-        
-        if (map.containsKey(node)) {
-            return map.get(node);
-        }
-        
-        Node newNode = new Node(node.val, new ArrayList<>());
-        map.put(node, newNode);
-        
-        for (Node n : node.neighbors) {
-            newNode.neighbors.add(cloneGraph(n));
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(node);
+    map.put(node, new Node(node.val, new ArrayList<>()));
+    while (!queue.isEmpty()) {
+      Node removed = queue.remove();
+      for (Node neighbor : removed.neighbors) {
+        if (!map.containsKey(neighbor)) {
+          map.put(neighbor, new Node(neighbor.val, new ArrayList<>()));
+          queue.add(neighbor);
         }
-        
-        return newNode;
+        map.get(removed).neighbors.add(map.get(neighbor));
+      }
     }
+    return map.get(node);
+  }
 }
diff --git a/Medium/Reorder List.java b/Medium/Reorder List.java
index 73a7ebe7..beb3390b 100644
--- a/Medium/Reorder List.java	
+++ b/Medium/Reorder List.java	
@@ -3,86 +3,47 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    
-    public static void reorderList(ListNode head) {
-        if (head == null || head.next == null) return;
-        int midLength = getLength(head)/2;
-        ListNode curr = head;
-        int count = 1;
-
-        while (count < midLength) {
-            curr = curr.next;
-            count++;
-        }
-
-        ListNode rev = reverse(curr.next);
-        curr = head;
-
-        while (midLength-- > 1) {
-            curr = curr.next;
-        }
-
-        curr.next = null;
-        curr = head;
-
-        head = merge(curr, rev);
+  public void reorderList(ListNode head) {
+    if (head == null || head.next == null) {
+      return;
     }
-
-    private static ListNode merge(ListNode head1, ListNode head2) {
-        ListNode ans = head1;
-        ListNode pCurr = head1;
-        ListNode qCurr = head2;
-
-        ListNode pNext = null;
-        ListNode qNext = null;
-        ListNode pPrev = null;
-
-        while (pCurr != null && qCurr != null) {
-            pNext = pCurr.next;
-            qNext = qCurr.next;
-
-            qCurr.next = pNext;
-            pCurr.next = qCurr;
-
-            if (pNext == null) {
-                pPrev = qCurr;
-            }
-
-            pCurr = pNext;
-            qCurr = qNext;
-        }
-
-        pPrev.next = qCurr;
-
-        return ans;
+    ListNode fast = head;
+    ListNode slow = head;
+    while (fast != null && fast.next != null) {
+      fast = fast.next.next;
+      slow = slow.next;
     }
-
-    private static ListNode reverse(ListNode root) {
-        ListNode prev = null;
-        ListNode curr = root;
-        ListNode next = null;
-
-        while (curr != null) {
-            next = curr.next;
-            curr.next = prev;
-            prev = curr;
-            curr = next;
-        }
-
-        return prev;
+    ListNode secondHalf = reverse(slow.next);
+    slow.next = null;
+    ListNode firstHalf = head;
+    ListNode firstNext = null;
+    ListNode secondNext = null;
+    while (firstHalf != null && secondHalf != null) {
+      firstNext = firstHalf.next;
+      secondNext = secondHalf.next;
+      firstHalf.next = secondHalf;
+      secondHalf.next = firstNext;
+      firstHalf = firstNext;
+      secondHalf = secondNext;
     }
-
-    private static int getLength(ListNode head) {
-        int count = 0;
-        while (head != null) {
-            count++;
-            head = head.next;
-        }
-
-        return count;
+  }
+  
+  private ListNode reverse(ListNode node) {
+    ListNode curr = node;
+    ListNode prev = null;
+    ListNode next = null;
+    while (curr != null) {
+      next = curr.next;
+      curr.next = prev;
+      prev = curr;
+      curr = next;
     }
+    return prev;
+  }
 }

From 16d2cc33d5dc319181bc3a727d3784e07fd053e5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 17 Jul 2020 10:02:44 -0500
Subject: [PATCH 0231/2175] Added 1 solution & modified 3 solutions

---
 Easy/Goat Latin.java                          | 40 +++++++++---
 Easy/Length of last word.java                 | 14 +++-
 Medium/Fraction to Recurring Decimal.java     | 65 +++++++++----------
 ...lute Diff Less Than or Equal to Limit.java | 29 +++++++++
 4 files changed, 99 insertions(+), 49 deletions(-)
 create mode 100644 Medium/Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit.java

diff --git a/Easy/Goat Latin.java b/Easy/Goat Latin.java
index c62aec2c..28b6b950 100644
--- a/Easy/Goat Latin.java	
+++ b/Easy/Goat Latin.java	
@@ -1,19 +1,39 @@
 class Solution {
   public String toGoatLatin(String S) {
-    StringBuilder addAString = new StringBuilder("a");
     StringBuilder sb = new StringBuilder();
-    Set<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u'));
-    String[] strs = S.split("\\s+");
-    for (int i = 0; i < strs.length; i++) {
-      if (vowels.contains(Character.toLowerCase(strs[i].charAt(0)))) {
-        sb.append(strs[i]);
+    StringBuilder temp = new StringBuilder();
+    String vowels = "aeiouAEIOU";
+    StringBuilder aAppend = new StringBuilder("a");
+    int idx = 0;
+    int n = S.length();
+    Boolean startVowel = null;
+    while (idx < n) {
+      if (startVowel == null) {
+        startVowel = vowels.indexOf(S.charAt(idx)) != -1;
+      }
+      if (S.charAt(idx) == ' ' || idx == n - 1) {
+        if (S.charAt(idx) != ' ') {
+          temp.append(S.charAt(idx));
+        }
+        if (!startVowel) {
+          char c = temp.charAt(0);
+          temp.deleteCharAt(0);
+          temp.append(c);
+        }
+        temp.append("ma").append(aAppend.toString());
+        sb.append(temp.toString());
+        temp.setLength(0);
+        aAppend.append("a");
+        startVowel = null;
+        if (idx != n - 1) {
+          sb.append(" ");
+        }
       }
       else {
-        sb.append(strs[i].substring(1)).append(strs[i].charAt(0));
+        temp.append(S.charAt(idx));
       }
-      sb.append("ma").append(addAString.toString()).append(" ");
-      addAString.append("a");
+      idx++;
     }
-    return sb.toString().trim();
+    return sb.toString();
   }
 }
diff --git a/Easy/Length of last word.java b/Easy/Length of last word.java
index 5126a352..8768e506 100644
--- a/Easy/Length of last word.java	
+++ b/Easy/Length of last word.java	
@@ -1,6 +1,14 @@
 class Solution {
-    public int lengthOfLastWord(String s) {
-        String[] strs = s.split("\\s");
-        return strs.length > 0 ? strs[strs.length-1].length() : 0;
+  public int lengthOfLastWord(String s) {
+    int count = 0;
+    int idx = s.length() - 1;
+    while (idx >= 0 && s.charAt(idx) == ' ') {
+      idx--;
     }
+    while (idx >= 0 && s.charAt(idx) != ' ') {
+      idx--;
+      count++;
+    }
+    return count;
+  }
 }
diff --git a/Medium/Fraction to Recurring Decimal.java b/Medium/Fraction to Recurring Decimal.java
index 352a2c3e..8e0385ba 100644
--- a/Medium/Fraction to Recurring Decimal.java	
+++ b/Medium/Fraction to Recurring Decimal.java	
@@ -1,39 +1,32 @@
 class Solution {
-    public String fractionToDecimal(int numerator, int denominator) {
-        if (numerator == 0) {
-            return "0";
-        }
-        
-        StringBuilder fraction = new StringBuilder();
-        if (numerator < 0 ^ denominator < 0) {
-            fraction.append("-");
-        }
-        
-        long dividend = Math.abs(Long.valueOf(numerator));
-        long divisor = Math.abs(Long.valueOf(denominator));
-        
-        fraction.append(String.valueOf(dividend / divisor));
-        long remainder = dividend % divisor;
-        
-        if (remainder == 0) {
-            return fraction.toString();
-        }
-        
-        fraction.append('.');
-        Map<Long, Integer> map = new HashMap<>();
-        while (remainder != 0) {
-            if (map.containsKey(remainder)) {
-                fraction.insert(map.get(remainder), "(");
-                fraction.append(')');
-                break;
-            }
-            
-            map.put(remainder, fraction.length());
-            remainder *= 10;
-            fraction.append(String.valueOf(remainder / divisor));
-            remainder %= divisor;
-        }
-        
-        return fraction.toString();
+  public String fractionToDecimal(int numerator, int denominator) {
+    if (numerator == 0) {
+      return "0";
     }
+    StringBuilder fraction = new StringBuilder();
+    if (numerator < 0 ^ denominator < 0) {
+      fraction.append("-");
+    }
+    long dividend = Math.abs((long) numerator);
+    long divisor = Math.abs((long) denominator);
+    fraction.append(String.valueOf(dividend / divisor));
+    long remainder = dividend % divisor;
+    if (remainder == 0) {
+      return fraction.toString();
+    }
+    fraction.append(".");
+    Map<Long, Integer> map = new HashMap<>();
+    while (remainder != 0) {
+      if (map.containsKey(remainder)) {
+        fraction.insert(map.get(remainder), "(");
+        fraction.append(")");
+        break;
+      }
+      map.put(remainder, fraction.length());
+      remainder *= 10;
+      fraction.append(String.valueOf(remainder / divisor));
+      remainder %= divisor;
+    }
+    return fraction.toString();
+  }
 }
diff --git a/Medium/Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit.java b/Medium/Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit.java
new file mode 100644
index 00000000..947954f3
--- /dev/null
+++ b/Medium/Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int longestSubarray(int[] nums, int limit) {
+    int maxSize = 0;
+    int start = 0;
+    Deque<Integer> maxHeap = new ArrayDeque<>();
+    Deque<Integer> minHeap = new ArrayDeque<>();
+    for (int i = 0; i < nums.length; i++) {
+      while (!maxHeap.isEmpty() && maxHeap.peekLast() < nums[i]) {
+        maxHeap.pollLast();
+      }
+      while (!minHeap.isEmpty() && minHeap.peekLast() > nums[i]) {
+        minHeap.pollLast();
+      }
+      minHeap.add(nums[i]);
+      maxHeap.add(nums[i]);
+      while (maxHeap.peek() - minHeap.peek() > limit) {
+        if (maxHeap.peek() == nums[start]) {
+          maxHeap.poll();
+        }
+        if (minHeap.peek() == nums[start]) {
+          minHeap.poll();
+        }
+        start++;
+      }
+      maxSize = Math.max(maxSize, i - start + 1);
+    }
+    return maxSize;
+  }
+}

From 13f98862ffd31acb1b1fdf1162714611ab8c3b0a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 17 Jul 2020 13:12:21 -0500
Subject: [PATCH 0232/2175] Added 1 solution & modified 3 solutions

---
 Easy/Duplicate Zeros.java      | 39 +++++++-------
 Hard/Concatenated Words.java   | 58 ++++++++++++++++++++
 Hard/Stream of Characters.java | 96 +++++++++++++++-------------------
 Medium/Map Sum Pairs.java      | 60 ++++++++++++++-------
 4 files changed, 162 insertions(+), 91 deletions(-)
 create mode 100644 Hard/Concatenated Words.java

diff --git a/Easy/Duplicate Zeros.java b/Easy/Duplicate Zeros.java
index 62b546f7..54a3592a 100644
--- a/Easy/Duplicate Zeros.java	
+++ b/Easy/Duplicate Zeros.java	
@@ -1,22 +1,23 @@
 class Solution {
-    public void duplicateZeros(int[] arr) {
-        int n = arr.length;
-        int count = 0;
-        
-        for (int i = 0; i < arr.length; i++, count++) {
-            if (arr[i] == 0) {
-                count++;
-            }
-        }
-        
-        for (int i = n - 1; i >= 0; i--) {
-            if (--count < n) {
-                arr[count] = arr[i];
-            }
-            
-            if (arr[i] == 0 && --count < n) {
-                arr[count] = 0;
-            }
-        }
+  public void duplicateZeros(int[] arr) {
+    int numOfZeros = 0;
+    for (int num : arr) {
+      numOfZeros += num == 0 ? 1 : 0;
     }
+    int i = arr.length - 1;
+    int j = arr.length + numOfZeros - 1;
+    while (i != j) {
+      insert(arr, i, j--);
+      if (arr[i] == 0) {
+        insert(arr, i, j--);
+      }
+      i--;
+    }
+  }
+  
+  private void insert(int[] arr, int i, int j) {
+    if (j < arr.length) {
+      arr[j] = arr[i];
+    }
+  }
 }
diff --git a/Hard/Concatenated Words.java b/Hard/Concatenated Words.java
new file mode 100644
index 00000000..470c05d6
--- /dev/null
+++ b/Hard/Concatenated Words.java	
@@ -0,0 +1,58 @@
+class Solution {
+  public List<String> findAllConcatenatedWordsInADict(String[] words) {
+    TrieNode root = new TrieNode('-');
+    for (String word : words) {
+      addWord(word, root);
+    }
+    List<String> concatenations = new ArrayList<>();
+    for (String word : words) {
+      if (isConcatentation(word, root, 0, 0)) {
+        concatenations.add(word);
+      }
+    }
+    return concatenations;
+  }
+  
+  private void addWord(String s, TrieNode root) {
+    TrieNode curr = root;
+    for (int i = 0; i < s.length(); i++) {
+      if (!curr.map.containsKey(s.charAt(i))) {
+        curr.map.put(s.charAt(i), new TrieNode(s.charAt(i)));
+      }
+      curr = curr.map.get(s.charAt(i));
+    }
+    curr.isWord = true;
+  }
+  
+  private boolean isConcatentation(String s, TrieNode root, int idx, int count) {
+    TrieNode curr = root;
+    for (int i = idx; i < s.length(); i++) {
+      if (!curr.map.containsKey(s.charAt(i))) {
+        return false;
+      }
+      if (curr.map.get(s.charAt(i)).isWord) {
+        if (i == s.length() - 1) {
+          return count >= 1;
+        }
+        if (isConcatentation(s, root, i + 1, count + 1)) {
+          return true;
+        }
+      }
+      curr = curr.map.get(s.charAt(i));
+    }
+    return false;
+  }
+}
+
+
+class TrieNode {
+  char c;
+  Map<Character, TrieNode> map;
+  boolean isWord;
+  
+  public TrieNode(char c) {
+    this.c = c;
+    map = new HashMap<>();
+    isWord = false;
+  }
+}
diff --git a/Hard/Stream of Characters.java b/Hard/Stream of Characters.java
index 6cbd64e8..010be550 100644
--- a/Hard/Stream of Characters.java	
+++ b/Hard/Stream of Characters.java	
@@ -1,61 +1,39 @@
 class StreamChecker {
-    String[] words;
-    TrieNode root;
-    StringBuilder sb = new StringBuilder();
-    public StreamChecker(String[] words) {
-        this.words = words;
-        root = new TrieNode('#');
-        treeify(words);
+  TrieNode root;
+  Deque<Character> stream;
+  public StreamChecker(String[] words) {
+    root = new TrieNode('-');
+    stream = new ArrayDeque();
+    for (String word : words) {
+      addWord(word);
     }
-
-    private void treeify (String[] words) {
-        for (String word : words) {
-            TrieNode curr = root;
-            for (int i = word.length() - 1; i >= 0; i--) {
-                char c = word.charAt(i);
-                if (curr.childrens[c - 'a'] == null) {
-                    curr.childrens[c - 'a'] = new TrieNode(c);
-                }
-
-                curr = curr.childrens[c - 'a'];
-
-                if (i == 0) {
-                    curr.isWord = true;
-                }
-            }
-        }
+  }
+  
+  private void addWord(String s) {
+    TrieNode curr = root;
+    for (int i = s.length() - 1; i >= 0; i--) {
+      if (!curr.map.containsKey(s.charAt(i))) {
+        curr.map.put(s.charAt(i), new TrieNode(s.charAt(i)));
+      }
+      curr = curr.map.get(s.charAt(i));
     }
-
-    public boolean query(char letter) {
-        sb.append(letter);
-        TrieNode curr = root;
-        for (int i = sb.length() - 1; i >= 0; i--) {
-            if (curr.childrens[sb.charAt(i) - 'a'] != null) {
-                curr = curr.childrens[sb.charAt(i) - 'a'];
-            }
-            else {
-                break;
-            }
-
-            if (curr.isWord) {
-                return true;
-            }
-        }
-
+    curr.isWord = true;
+  }
+
+  public boolean query(char letter) {
+    stream.addFirst(letter);
+    TrieNode curr = root;
+    for (char c : stream) {
+      if (curr.isWord) {
+        return true;
+      }
+      if (!curr.map.containsKey(c)) {
         return false;
+      }
+      curr = curr.map.get(c);
     }
-
-    class TrieNode {
-        char key;
-        TrieNode[] childrens;
-        boolean isWord;
-
-        public TrieNode (char key) {
-            this.key = key;
-            this.childrens = new TrieNode[26];
-            isWord = false;
-        }
-    }
+    return curr.isWord;
+  }
 }
 
 /**
@@ -63,3 +41,15 @@ public TrieNode (char key) {
  * StreamChecker obj = new StreamChecker(words);
  * boolean param_1 = obj.query(letter);
  */
+
+class TrieNode {
+  char c;
+  Map<Character, TrieNode> map;
+  boolean isWord;
+  
+  public TrieNode(char c) {
+    this.c = c;
+    map = new HashMap<>();
+    isWord = false;
+  }
+}
diff --git a/Medium/Map Sum Pairs.java b/Medium/Map Sum Pairs.java
index bc65aa1a..39eb3afe 100644
--- a/Medium/Map Sum Pairs.java	
+++ b/Medium/Map Sum Pairs.java	
@@ -1,26 +1,36 @@
 class MapSum {
 
-    /** Initialize your data structure here. */
-    Map<String, Integer> map = new HashMap<String, Integer>();
-    public MapSum() {
-        
-    }
-    
-    public void insert(String key, int val) {
-        map.put(key, val);
+  /** Initialize your data structure here. */
+  TrieNode root;
+  Map<String, Integer> map;
+  public MapSum() {
+    root = new TrieNode('-');
+    map = new HashMap<>();
+  }
+
+  public void insert(String key, int val) {
+    int delta = val - map.getOrDefault(key, 0);
+    map.put(key, val);
+    TrieNode curr = root;
+    for (int i = 0; i < key.length(); i++) {
+      if (!curr.map.containsKey(key.charAt(i))) {
+        curr.map.put(key.charAt(i), new TrieNode(key.charAt(i)));
+      }
+      curr = curr.map.get(key.charAt(i));
+      curr.score += delta;
     }
-    
-    public int sum(String prefix) {
-        int sum = 0;
-        for (Map.Entry<String, Integer> entry : map.entrySet()) {
-            String s = entry.getKey();
-            if (s.length() >= prefix.length() && s.substring(0,prefix.length()).equals(prefix)) {
-                sum += entry.getValue();
-            }
-        }
-        
-        return sum;
+  }
+
+  public int sum(String prefix) {
+    TrieNode curr = root;
+    for (int i = 0; i < prefix.length(); i++) {
+      if (!curr.map.containsKey(prefix.charAt(i))) {
+        return 0;
+      }
+      curr = curr.map.get(prefix.charAt(i));
     }
+    return curr.score;
+  }
 }
 
 /**
@@ -29,3 +39,15 @@ public int sum(String prefix) {
  * obj.insert(key,val);
  * int param_2 = obj.sum(prefix);
  */
+
+class TrieNode {
+  char c;
+  Map<Character, TrieNode> map;
+  int score;
+  
+  public TrieNode(char c) {
+    this.c = c;
+    map = new HashMap<>();
+    score = 0;
+  }
+}

From 62c43f5671306bf2a24dc66479a5f6c6e9e35bdb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 18 Jul 2020 17:19:27 -0500
Subject: [PATCH 0233/2175] Modified 3 solutions

---
 Easy/Number of Days Between Two Dates.java | 29 ++++++++++
 Easy/SqrtX.java                            | 26 +++++++--
 Medium/Course Schedule II.java             | 66 ++++++++--------------
 3 files changed, 75 insertions(+), 46 deletions(-)
 create mode 100644 Easy/Number of Days Between Two Dates.java

diff --git a/Easy/Number of Days Between Two Dates.java b/Easy/Number of Days Between Two Dates.java
new file mode 100644
index 00000000..e42eb7d4
--- /dev/null
+++ b/Easy/Number of Days Between Two Dates.java	
@@ -0,0 +1,29 @@
+class Solution {
+  private int[] daysOfMonth = new int[]{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+  
+  public int daysBetweenDates(String date1, String date2) {
+    return Math.abs(daysFrom1971(date1) - daysFrom1971(date2));
+  }
+  
+  private int daysFrom1971(String date) {
+    String[] dateArr = date.split("-");
+    int year = Integer.parseInt(dateArr[0]);
+    int month = Integer.parseInt(dateArr[1]);
+    int day = Integer.parseInt(dateArr[2]);
+    int numOfDays = day;
+    for (int y = 1971; y < year; y++) {
+      numOfDays += isLeapYear(y) ? 366 : 365;
+    }
+    for (int m = 0; m < month - 1; m++) {
+      numOfDays += daysOfMonth[m];
+    }
+    if (month > 2 && isLeapYear(year)) {
+      numOfDays++;
+    }
+    return numOfDays;
+  }
+  
+  private boolean isLeapYear(int year) {
+    return year % 400 == 0 || (year % 100 != 0 && year % 4 == 0);
+  }
+}
diff --git a/Easy/SqrtX.java b/Easy/SqrtX.java
index 0cd9c2c6..51c13b9c 100644
--- a/Easy/SqrtX.java
+++ b/Easy/SqrtX.java
@@ -1,5 +1,23 @@
-public class Solution {
-    public int mySqrt(int x) {
-        return (int)Math.sqrt((double)x);
+class Solution {
+  public int mySqrt(int x) {
+    if (x < 2) {
+      return x;
     }
-}
\ No newline at end of file
+    int start = 2;
+    int end = x / 2;
+    while (start <= end) {
+      int mid = start + (end - start) / 2;
+      long num = (long) mid * mid; 
+      if (num > x) {
+        end = mid - 1;
+      }
+      else if (num < x) {
+        start = mid + 1;
+      }
+      else {
+        return mid;
+      }
+    }
+    return end;
+  }
+}
diff --git a/Medium/Course Schedule II.java b/Medium/Course Schedule II.java
index 3fa48520..4dc8b847 100644
--- a/Medium/Course Schedule II.java	
+++ b/Medium/Course Schedule II.java	
@@ -1,47 +1,29 @@
 class Solution {
-    public int[] findOrder(int numCourses, int[][] prerequisites) {
-        Map<Integer, List<Integer>> map = new HashMap<>();
-        for (int[] prerequisite : prerequisites) {
-            map.computeIfAbsent(prerequisite[0], k -> new ArrayList<>()).add(prerequisite[1]);
-        }
-
-        boolean[] registered = new boolean[numCourses];
-        Stack<Integer> stack = new Stack<>();
-        for (int i = 0; i < numCourses; i++) {
-            if (!isDeadlock(i, map, stack, registered, new boolean[numCourses])) {
-                return new int[]{};
-            }
-        }
-
-        int[] ans = new int[numCourses];
-        int idx = numCourses - 1;
-        while (!stack.isEmpty()) {
-            ans[idx--] = stack.pop();
-        }
-
-        return ans;
+  public int[] findOrder(int numCourses, int[][] prerequisites) {
+    Map<Integer, List<Integer>> map = new HashMap<>();
+    int[] prereqCount = new int[numCourses];
+    for (int[] prerequisite : prerequisites) {
+      prereqCount[prerequisite[0]]++;
+      map.computeIfAbsent(prerequisite[1], k -> new ArrayList<>()).add(prerequisite[0]);
     }
-
-    private boolean isDeadlock(int c1, Map<Integer, List<Integer>> map, Stack<Integer> stack, boolean[] registered, boolean[] visited) {
-        if (registered[c1]) {
-            return true;
-        }
-
-        if (visited[c1]) {
-            return false;
-        }
-
-        visited[c1] = true;
-        for (Integer prereq : map.getOrDefault(c1, new ArrayList<>())) {
-            if (!isDeadlock(prereq, map, stack, registered, visited)) {
-                return false;
-            }
+    Queue<Integer> queue = new LinkedList<>();
+    for (int i = 0; i < numCourses; i++) {
+      if (prereqCount[i] == 0) {
+        queue.add(i);
+      }
+    }
+    int[] ans = new int[numCourses];
+    int idx = 0;
+    while (!queue.isEmpty()) {
+      int removed = queue.remove();
+      for (Integer dependentCourse : map.getOrDefault(removed, new ArrayList<>())) {
+        prereqCount[dependentCourse]--;
+        if (prereqCount[dependentCourse] == 0) {
+          queue.add(dependentCourse);
         }
-
-        registered[c1] = true;
-        stack.push(c1);
-
-        return true;
+      }
+      ans[idx++] = removed;
     }
-
+    return idx == numCourses ? ans : new int[]{};
+  }
 }

From 928a57d1fe834ee14ad462df95c3e6223fc68dba Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 19 Jul 2020 07:42:56 -0500
Subject: [PATCH 0234/2175] Added 1 solution & modified 3 solutions

---
 Easy/Add Binary.java                         | 58 +++++-----------
 Easy/Add to Array-Form of Integer.java       | 72 +++++---------------
 Easy/Water Bottles.java                      | 13 ++++
 Medium/Next Greater Node In Linked List.java | 65 ++++++++----------
 4 files changed, 75 insertions(+), 133 deletions(-)
 create mode 100644 Easy/Water Bottles.java

diff --git a/Easy/Add Binary.java b/Easy/Add Binary.java
index 3b4aacda..b51d82be 100644
--- a/Easy/Add Binary.java	
+++ b/Easy/Add Binary.java	
@@ -1,45 +1,19 @@
 class Solution {
-    public String addBinary(String a, String b) {
-        StringBuilder sb = new StringBuilder();
-        int carry = 0;
-        int idx1 = a.length() - 1;
-        int idx2 = b.length() - 1;
-        
-        while (idx1 >= 0 && idx2 >= 0) {
-            if (a.charAt(idx1) == '1' && b.charAt(idx2) == '1') {
-                sb.append(carry == 1 ? 1 : 0);
-                carry = 1;
-            }
-            else if (a.charAt(idx1) == '1' || b.charAt(idx2) == '1') {
-                sb.append(carry == 0 ? 1 : 0);
-            }
-            else {
-                sb.append(carry);
-                carry = 0;
-            }
-            
-            idx1--;
-            idx2--;
-        }
-        
-        String remainingString = a.length() > b.length() ? a : b;
-        int idx = Math.max(idx2, idx1);
-        while (idx >= 0) {
-            if (remainingString.charAt(idx) == '1') {
-                sb.append(carry == 1 ? 0 : 1);
-            }
-            else {
-                sb.append(carry);
-                carry = 0;
-            }
-            
-            idx--;
-        }
-        
-        if (carry > 0) {
-            sb.append(carry);
-        }
-        
-        return sb.reverse().toString();
+  public String addBinary(String a, String b) {
+    int carry = 0;
+    StringBuilder sb = new StringBuilder();
+    int idxA = a.length() - 1;
+    int idxB = b.length() - 1;
+    while (idxA >= 0 || idxB >= 0 || carry > 0) {
+      int temp = (
+        (idxA >= 0 ? Character.getNumericValue(a.charAt(idxA--)) : 0) + 
+        (idxB >= 0 ? Character.getNumericValue(b.charAt(idxB--)) : 0) + 
+        carry
+      );
+      carry = temp > 1 ? 1 : 0;
+      temp = temp > 1 ? (temp == 2 ? 0 : 1) : temp;
+      sb.append(temp);
     }
+    return sb.reverse().toString();
+  }
 }
diff --git a/Easy/Add to Array-Form of Integer.java b/Easy/Add to Array-Form of Integer.java
index be084446..c1ab95b2 100644
--- a/Easy/Add to Array-Form of Integer.java	
+++ b/Easy/Add to Array-Form of Integer.java	
@@ -1,58 +1,20 @@
 class Solution {
-    public List<Integer> addToArrayForm(int[] A, int K) {
-        int[] kArr = getArray(K);
-        int len1 = A.length - 1;
-        int len2 = kArr.length - 1;
-        int carry = 0;
-
-        List<Integer> list = new ArrayList<>();
-
-        while (len1 >= 0 || len2 >= 0) {
-            int temp = 0;
-
-            if (len1 >= 0 && len2 >= 0) {
-                temp = A[len1] + kArr[len2] + carry;
-                len1--;
-                len2--;
-            }
-            else if (len1 >= 0 && len2 < 0) {
-                temp = A[len1] + carry;
-                len1--;
-            }
-            else {
-                temp = kArr[len2] + carry;
-                len2--;
-            }
-
-            if (temp > 9) {
-                carry = temp / 10;
-                temp %= 10;
-            }
-            else {
-                carry = 0;
-            }
-
-            list.add(temp);
-        }
-
-        if (carry > 0) {
-            list.add(carry);
-        }
-
-        Collections.reverse(list);
-
-        return list;
-    }
-
-    private int[] getArray(int k) {
-        int len = String.valueOf(k).length();
-        int[] ans = new int[len];
-
-        for (int i=len-1; i>=0; i--) {
-            ans[i] = k % 10;
-            k /= 10;
-        }
-
-        return ans;
+  public List<Integer> addToArrayForm(int[] A, int K) {
+    List<Integer> list = new ArrayList<>();
+    int idx = A.length - 1;
+    int carry = 0;
+    while (K > 0 || idx >= 0 || carry > 0) {
+      int temp = (
+        (K > 0 ? K % 10 : 0) +
+        (idx >= 0 ? A[idx--] : 0) + 
+        carry
+      );
+      K /= 10;
+      carry = temp > 9 ? temp / 10 : 0;
+      temp = temp > 9 ? temp % 10 : temp;
+      list.add(temp);
     }
+    Collections.reverse(list);
+    return list;
+  }
 }
diff --git a/Easy/Water Bottles.java b/Easy/Water Bottles.java
new file mode 100644
index 00000000..5ef90a4f
--- /dev/null
+++ b/Easy/Water Bottles.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int numWaterBottles(int numBottles, int numExchange) {
+    int bottleCount = 0;
+    int emptyBottles = 0;
+    while (numBottles > 0) {
+      bottleCount += numBottles;
+      emptyBottles += numBottles;
+      numBottles = emptyBottles / numExchange;
+      emptyBottles %= numExchange;
+    }
+    return bottleCount;
+  }
+}
diff --git a/Medium/Next Greater Node In Linked List.java b/Medium/Next Greater Node In Linked List.java
index 5b81f90e..871a6960 100644
--- a/Medium/Next Greater Node In Linked List.java	
+++ b/Medium/Next Greater Node In Linked List.java	
@@ -3,45 +3,38 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public int[] nextLargerNodes(ListNode head) {
-        ListNode rev = reverse(head);
-        Stack<Integer> stack = new Stack<>();
-        List<Integer> list = new ArrayList<>();
-        
-        while (rev != null) {
-            while (!stack.isEmpty() && stack.peek() <= rev.val) {
-                stack.pop();
-            }
-            
-            list.add(stack.isEmpty() ? 0 : stack.peek());
-            stack.push(rev.val);
-            rev = rev.next;
-        }
-        
-        int[] arr = new int[list.size()];
-        for (int i = 0, j=list.size() - 1; i < list.size(); i++,j--) {
-            arr[i] = list.get(j);
-        }
-        
-        return arr;
+  public int[] nextLargerNodes(ListNode head) {
+    // Reverse the list
+    ListNode curr = head;
+    ListNode prev = null;
+    ListNode next = null;
+    int count = 0;
+    while (curr != null) {
+      next = curr.next;
+      curr.next = prev;
+      prev = curr;
+      curr = next;
+      count++;
     }
-    
-    private ListNode reverse(ListNode head) {
-        ListNode curr = head;
-        ListNode prev = null;
-        ListNode next = null;
-        
-        while (curr != null) {
-            next = curr.next;
-            curr.next = prev;
-            prev = curr;
-            curr = next;
-        }
-        
-        return prev;
+    curr = prev;
+    Stack<Integer> stack = new Stack<>();
+    int[] ans = new int[count];
+    int idx = count - 1;
+    while (curr != null) {
+      // Keep track of next greatest value node
+      while (!stack.isEmpty() && stack.peek() <= curr.val) {
+        stack.pop();
+      }
+      ans[idx--] = stack.isEmpty() ? 0 : stack.peek(); 
+      stack.push(curr.val);
+      curr = curr.next;
     }
+    return ans;
+  }
 }

From 8337317c4fc4b883cb5915b97e520fa5dfd391e5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 19 Jul 2020 19:45:38 -0500
Subject: [PATCH 0235/2175] Added 2 solutions & modified 2 solutions

---
 Easy/Array Transformation.java                | 17 +++++++
 Easy/Merge Two Sorted Lists.java              | 46 +++++++++----------
 Medium/Find all Duplicates in an Array.java   | 22 ++++-----
 ...s in the Sub-Tree With the Same Label.java | 30 ++++++++++++
 4 files changed, 78 insertions(+), 37 deletions(-)
 create mode 100644 Easy/Array Transformation.java
 create mode 100644 Medium/Number of Nodes in the Sub-Tree With the Same Label.java

diff --git a/Easy/Array Transformation.java b/Easy/Array Transformation.java
new file mode 100644
index 00000000..76be3292
--- /dev/null
+++ b/Easy/Array Transformation.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public List<Integer> transformArray(int[] arr) {
+    int[] ans = new int[arr.length];
+    while (!Arrays.equals(ans, arr)) {
+      ans = arr.clone();
+      for (int i = 1; i < arr.length - 1; i++) {
+        if (ans[i] > ans[i - 1] && ans[i] > ans[i + 1]) {
+          arr[i]--;
+        }
+        else if (ans[i - 1] > ans[i] && ans[i + 1] > ans[i]) {
+          arr[i]++;
+        }
+      }
+    }
+    return Arrays.stream(ans).boxed().collect(Collectors.toList());
+  }
+}
diff --git a/Easy/Merge Two Sorted Lists.java b/Easy/Merge Two Sorted Lists.java
index e65f0827..f4b4c5b5 100644
--- a/Easy/Merge Two Sorted Lists.java	
+++ b/Easy/Merge Two Sorted Lists.java	
@@ -3,33 +3,29 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
-        
-        if (l1 == null && l2 == null) {
-            return null;
-        }
-        
-        if (l1 == null && l2 != null) {
-            return l2;
-        }
-        
-        if (l1 != null && l2 == null) {
-            return l1;
-        }
-        
-        ListNode head;
-        if(l1.val < l2.val){
-            head = l1;
-            head.next = mergeTwoLists(l1.next, l2);
-        }
-        else{
-            head = l2;
-            head.next = mergeTwoLists(l1, l2.next);
-        }
-        return head;
+  public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+    ListNode dummy = new ListNode(-1);
+    ListNode curr = dummy;
+    while (l1 != null || l2 != null) {
+      int val = Math.min(
+        (l1 == null ? Integer.MAX_VALUE : l1.val),
+        (l2 == null ? Integer.MAX_VALUE : l2.val)
+      );
+      curr.next = new ListNode(val);
+      curr = curr.next;
+      if (l1 != null && l1.val == val) {
+        l1 = l1.next;
+      }
+      else {
+        l2 = l2.next;
+      }
     }
+    return dummy.next;
+  }
 }
diff --git a/Medium/Find all Duplicates in an Array.java b/Medium/Find all Duplicates in an Array.java
index b1708766..d4219751 100644
--- a/Medium/Find all Duplicates in an Array.java	
+++ b/Medium/Find all Duplicates in an Array.java	
@@ -1,14 +1,12 @@
-public class Solution {
-    
-    public List<Integer> findDuplicates(int[] nums) {
-        List<Integer> res = new ArrayList<>();
-        for (int i = 0; i < nums.length; ++i) {
-            int index = Math.abs(nums[i])-1;
-            if (nums[index] < 0)
-                res.add(Math.abs(index+1));
-            nums[index] = -nums[index];
-        }
-        return res;
+class Solution {
+  public List<Integer> findDuplicates(int[] nums) {
+    List<Integer> list = new ArrayList<>();
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[Math.abs(nums[i]) - 1] < 0) {
+        list.add(Math.abs(nums[i]));
+      }
+      nums[Math.abs(nums[i]) - 1] *= -1;
     }
+    return list;
+  }
 }
-
diff --git a/Medium/Number of Nodes in the Sub-Tree With the Same Label.java b/Medium/Number of Nodes in the Sub-Tree With the Same Label.java
new file mode 100644
index 00000000..473b9052
--- /dev/null
+++ b/Medium/Number of Nodes in the Sub-Tree With the Same Label.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public int[] countSubTrees(int n, int[][] edges, String labels) {
+    Map<Integer, List<Integer>> map = new HashMap<>();
+    for (int[] edge : edges) {
+      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+      map.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    }
+    int[] count = new int[n];
+    Set<Integer> set = new HashSet<>();
+    dfs(map, 0, labels, count, set);
+    return count;
+  }
+  
+  private int[] dfs(Map<Integer, List<Integer>> map, int curr, String labels, int[] count, Set<Integer> set) {
+    int[] cnt = new int[26];
+    if (set.add(curr)) {
+      char c = labels.charAt(curr);
+      for (Integer child : map.getOrDefault(curr, new ArrayList<>())) {
+        int[] temp = dfs(map, child, labels, count, set);
+        for (int i = 0; i < 26; i++) {
+          cnt[i] += temp[i];
+        }
+      }
+      cnt[c - 'a']++;
+      count[curr] = cnt[c - 'a'];
+    }
+    return cnt;
+  }
+}
+

From 768d251f6361c498f69ac209535e7439d690dbd1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 20 Jul 2020 10:00:50 -0500
Subject: [PATCH 0236/2175] Added 1 solution & modified 3 solutions

---
 Easy/Best Time to Buy and Sell Stock.java     |  15 ++
 Easy/Best time to buy & sell a stock.java     |  21 ---
 Hard/LRU Cache.java                           | 163 ++++++++----------
 ...ary Tree Zigzag Level Order Traversal.java |  46 +++++
 Medium/Number of Islands.java                 |  56 +++---
 5 files changed, 154 insertions(+), 147 deletions(-)
 create mode 100644 Easy/Best Time to Buy and Sell Stock.java
 delete mode 100644 Easy/Best time to buy & sell a stock.java
 create mode 100644 Medium/Binary Tree Zigzag Level Order Traversal.java

diff --git a/Easy/Best Time to Buy and Sell Stock.java b/Easy/Best Time to Buy and Sell Stock.java
new file mode 100644
index 00000000..a30f4e9b
--- /dev/null
+++ b/Easy/Best Time to Buy and Sell Stock.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int maxProfit(int[] prices) {
+    int maxProfit = 0;
+    int currMin = Integer.MAX_VALUE;
+    for (int price : prices) {
+      if (price > currMin) {
+        maxProfit = Math.max(maxProfit, price - currMin);
+      }
+      else {
+        currMin = price;
+      }
+    }
+    return maxProfit;
+  }
+}
diff --git a/Easy/Best time to buy & sell a stock.java b/Easy/Best time to buy & sell a stock.java
deleted file mode 100644
index d03f8686..00000000
--- a/Easy/Best time to buy & sell a stock.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-    public int maxProfit(int[] prices) {
-        if (prices.length == 0) return 0;
-        
-        int min = prices[0];
-        int profit = 0;
-        
-        for (int i=1;i<prices.length;i++) {
-            if (prices[i] < min) {
-                min = prices[i];
-            }
-            else {
-                if (prices[i] - min > profit) {
-                    profit = prices[i] - min;
-                }
-            }
-        }
-        
-        return profit;
-    }
-}
diff --git a/Hard/LRU Cache.java b/Hard/LRU Cache.java
index 34c92558..2f2c70c0 100644
--- a/Hard/LRU Cache.java	
+++ b/Hard/LRU Cache.java	
@@ -1,96 +1,79 @@
 class LRUCache {
-
-    Map<Integer, Node> map;
-    Node head, tail;
-    int capacity;
-    int count;
-
-    public LRUCache(int capacity) {
-        map = new HashMap<>();
-        this.capacity = capacity;
-
-        head = new Node();
-        head.previous = null;
-
-        tail = new Node();
-        tail.next = null;
-
-        head.next = tail;
-        tail.previous = head;
-
-        this.count = 0;
-    }
-
-    public int get(int key) {
-        Node node = map.get(key);
-
-        if (node == null) {
-            return -1;
-        }
-
-        moveToHead(node);
-        
-        return node.val;
-    }
-
-    private void moveToHead(Node node) {
-        removeNode(node);
-        addNode(node);
-    }
-
-    private void addNode(Node node) {
-        node.previous = head;
-        node.next = head.next;
-
-        head.next.previous = node;
-        head.next = node;
-    }
-
-    private Node popTail() {
-        Node res = tail.previous;
-        removeNode(res);
-
-        return res;
-    }
-
-    private void removeNode(Node node) {
-        Node pre = node.previous;
-        Node post = node.next;
-
-        pre.next = post;
-        post.previous = pre;
+  Node head;
+  Node tail;
+  Map<Integer, Node> map;
+  int capacity;
+  public LRUCache(int capacity) {
+    head = new Node(-1, -1);
+    tail = new Node(-1, -1);
+    head.next = tail;
+    tail.prev = head;
+    map = new HashMap<>();
+    this.capacity = capacity;
+  }
+
+  public int get(int key) {
+    if (!map.containsKey(key)) {
+      return -1;
     }
-
-    public void put(int key, int value) {
-        Node node = map.get(key);
-
-        if (node == null) {
-            Node newNode = new Node();
-            newNode.key = key;
-            newNode.val = value;
-
-            map.put(key, newNode);
-            addNode(newNode);
-
-            count++;
-
-            if (count > capacity) {
-                Node tail = popTail();
-                map.remove(tail.key);
-                count--;
-            }
-        }
-        else {
-            node.val = value;
-            moveToHead(node);
-        }
+    int val = map.get(key).val;
+    moveToFront(map.get(key));
+    return val;
+  }
+
+  public void put(int key, int value) {
+    if (!map.containsKey(key)) {
+      if (map.size() == capacity) {
+        evictKey(tail.prev);
+      }
+      Node node = new Node(key, value);
+      map.put(key, node);
+      node.next = head.next;
+      head.next.prev = node;
+      head.next = node;
+      node.prev = head;
     }
-
-    private class Node {
-        Node previous;
-        Node next;
-        int key;
-        int val;
+    else {
+      map.get(key).val = value;
+      moveToFront(map.get(key));
     }
+  }
+  
+  private void moveToFront(Node node) {
+    Node prev = node.prev;
+    node.next.prev = prev;
+    prev.next = node.next;
+    node.next = head.next;
+    head.next.prev = node;
+    node.prev = head;
+    head.next = node;
+  }
+  
+  private void evictKey(Node node) {
+    Node prev = node.prev;
+    node.next.prev = prev;
+    prev.next = node.next;
+    map.remove(node.key);
+  }
 }
 
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * LRUCache obj = new LRUCache(capacity);
+ * int param_1 = obj.get(key);
+ * obj.put(key,value);
+ */
+
+class Node {
+  int key;
+  int val;
+  Node next;
+  Node prev;
+  
+  public Node(int key, int val) {
+    this.key = key;
+    this.val = val;
+    next = null;
+    prev = null;
+  }
+}
diff --git a/Medium/Binary Tree Zigzag Level Order Traversal.java b/Medium/Binary Tree Zigzag Level Order Traversal.java
new file mode 100644
index 00000000..94f520ad
--- /dev/null
+++ b/Medium/Binary Tree Zigzag Level Order Traversal.java	
@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+    List<List<Integer>> ans = new ArrayList<>();
+    if (root == null) {
+      return ans;
+    }
+    Queue<TreeNode> queue = new LinkedList<>();
+    boolean leftToRight = true;
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      List<Integer> temp = new ArrayList<>();
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        temp.add(removed.val);
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+      if (!leftToRight) {
+        Collections.reverse(temp);
+      }
+      ans.add(temp);
+      leftToRight = !leftToRight;
+    }
+    return ans;
+  }
+}
diff --git a/Medium/Number of Islands.java b/Medium/Number of Islands.java
index fda78799..04ca052f 100644
--- a/Medium/Number of Islands.java	
+++ b/Medium/Number of Islands.java	
@@ -1,41 +1,25 @@
 class Solution {
-    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-    public int numIslands(char[][] grid) {
-        if (grid.length == 0 || grid[0].length == 0) {
-            return 0;
+  public int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public int numIslands(char[][] grid) {
+    int count = 0;
+    for (int i = 0;  i < grid.length; i++) {
+      for (int j = 0; j < grid[0].length; j++) {
+        if (grid[i][j] == '1') {
+          dfs(grid, i, j);
+          count++;
         }
-        
-        int countOfIslands = 0;
-        boolean[][] visited = new boolean[grid.length][grid[0].length];
-        int numOfRows = grid.length;
-        int numOfCols = grid[0].length;
-        
-        for (int i = 0; i < numOfRows; i++) {
-            for (int j = 0; j < numOfCols; j++) {
-                if (visited[i][j] || grid[i][j] == '0') {
-                    continue;
-                }
-                
-                dfs(grid, i, j, numOfRows, numOfCols, visited);
-                countOfIslands++;
-            }
-        }
-        
-        return countOfIslands;
+      }
     }
-    
-    private void dfs(char[][] grid, int x, int y, int numOfRows, int numOfCols, boolean[][] visited) {
-        if (x < 0 || x >= numOfRows || y < 0 || y >= numOfCols || visited[x][y]) {
-            return;
-        }
-        
-        visited[x][y] = true;
-        if (grid[x][y] == '0') {
-            return;
-        }
-        
-        for (int[] dir : dirs) {
-            dfs(grid, x + dir[0], y + dir[1], numOfRows, numOfCols, visited);
-        }
+    return count;
+  }
+  
+  private void dfs(char[][] grid, int i, int j) {
+    if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') {
+      return;
+    }
+    grid[i][j] = '0';
+    for (int[] dir : dirs) {
+      dfs(grid, i + dir[0], j + dir[1]);
     }
+  }
 }

From 70fc787eb0e7256a9f61a69a08ec97f0d5d743e6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 21 Jul 2020 09:51:17 -0500
Subject: [PATCH 0237/2175] Added 3 solutions & modified 5 solutions

---
 Easy/Last Stone Weight.java            | 18 +++-----
 Easy/Valid Mountain Array.java         | 19 ++++++++
 Easy/Valid Palindrome II.java          | 48 ++++++++++----------
 Easy/Valid Palindrome.java             | 39 +++++++++-------
 Medium/Invalid Transactions.java       | 46 +++++++++++++++++++
 Medium/Last Stone Weight II.java       | 19 ++++++++
 Medium/Time Based Key-Value Store.java | 63 +++++++++-----------------
 Medium/Word Search.java                | 31 ++++++-------
 8 files changed, 171 insertions(+), 112 deletions(-)
 create mode 100644 Easy/Valid Mountain Array.java
 create mode 100644 Medium/Invalid Transactions.java
 create mode 100644 Medium/Last Stone Weight II.java

diff --git a/Easy/Last Stone Weight.java b/Easy/Last Stone Weight.java
index 237236ac..abf2a4d9 100644
--- a/Easy/Last Stone Weight.java	
+++ b/Easy/Last Stone Weight.java	
@@ -1,20 +1,16 @@
 class Solution {
   public int lastStoneWeight(int[] stones) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
-      public int compare(Integer o1, Integer o2) {
-        return o2 - o1;
-      }
-    });
+    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
     for (int stone : stones) {
       pq.add(stone);
     }
-    while(pq.size() > 1) {
-      int y = pq.poll();
-      int x = pq.poll();
-      if (x != y) {
-        pq.add(y - x);
+    while (pq.size() > 1) {
+      int max1 = pq.poll();
+      int max2 = pq.poll();
+      if (max1 != max2) {
+        pq.add(max1 - max2);
       }
     }
-    return pq.isEmpty() ? 0 : pq.poll();
+    return pq.isEmpty() ? 0 : pq.peek();
   }
 }
diff --git a/Easy/Valid Mountain Array.java b/Easy/Valid Mountain Array.java
new file mode 100644
index 00000000..e8750107
--- /dev/null
+++ b/Easy/Valid Mountain Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public boolean validMountainArray(int[] A) {
+    if (A.length < 3) {
+      return false;
+    }
+    int idx = 0;
+    int n = A.length;
+    while (idx + 1 < n && A[idx] < A[idx + 1]) {
+      idx++;
+    }
+    if (idx == 0 || idx == n - 1) {
+      return false;
+    }
+    while (idx + 1 < n && A[idx] > A[idx + 1]) {
+      idx++;
+    }
+    return idx == n - 1;
+  }
+}
diff --git a/Easy/Valid Palindrome II.java b/Easy/Valid Palindrome II.java
index 24ac1c5c..f525f8ce 100644
--- a/Easy/Valid Palindrome II.java	
+++ b/Easy/Valid Palindrome II.java	
@@ -1,29 +1,27 @@
 class Solution {
-    public boolean validPalindrome(String s) {
-        if (isPalindrome(s)) return true;        
-    
-        int i=0;
-        int j = s.length()-1;
-         
-        while (i<j && s.charAt(i) == s.charAt(j)) {
-            i++;
-            j--;
-        }
-        
-        if (i>=j) {
-            return true;
-        }
-        
-        if (isPalindrome(s.substring(i+1,j+1)) || isPalindrome(s.substring(i,j))) {
-            return true;
-        }
-        
-        return false;
+  public boolean validPalindrome(String s) {
+    int start = 0;
+    int end = s.length() - 1;
+    while (start < end && s.charAt(start) == s.charAt(end)) {
+      start++;
+      end--;
     }
-    
-    public boolean isPalindrome(String s) {
-        StringBuilder sb = new StringBuilder("");
-        sb.append(s);
-        return s.equals(sb.reverse().toString());
+    if (start >= end) {
+      return true;
     }
+    if (isPalindrome(s.substring(start + 1, end + 1)) || isPalindrome(s.substring(start, end))) {
+      return true;
+    }
+    return false;
+  }
+  
+  private boolean isPalindrome(String s) {
+    int start = 0;
+    int end = s.length() - 1;
+    while (start < end && s.charAt(start) == s.charAt(end)) {
+      start++;
+      end--;
+    }
+    return start >= end;
+  }
 }
diff --git a/Easy/Valid Palindrome.java b/Easy/Valid Palindrome.java
index 50c1efd3..255d45ee 100644
--- a/Easy/Valid Palindrome.java	
+++ b/Easy/Valid Palindrome.java	
@@ -1,21 +1,26 @@
 class Solution {
-    public boolean isPalindrome(String s) {
-        StringBuilder sb = new StringBuilder("");
-        
-        for (char c : s.toCharArray()) {
-            if (Character.isLetterOrDigit(c)) {
-                sb.append(c);
-            }
+  public boolean isPalindrome(String s) {
+    int start = 0;
+    int end = s.length() - 1;
+    while (start < end) {
+      if (Character.isLetterOrDigit(s.charAt(start)) && Character.isLetterOrDigit(s.charAt(end))) {
+        char c1 = Character.isLetter(s.charAt(start)) ? Character.toLowerCase(s.charAt(start)) : s.charAt(start);
+        char c2 = Character.isLetter(s.charAt(end)) ? Character.toLowerCase(s.charAt(end)) : s.charAt(end);
+        if (c1 != c2) {
+          return false;
         }
-        
-        String S = sb.toString().toLowerCase();
-        
-        return isPalindromeImpl(S);
-    }
-    
-    public boolean isPalindromeImpl(String s) {
-        if (s.length() <= 1) return true;
-        
-        return s.charAt(0) == s.charAt(s.length()-1) && isPalindromeImpl(s.substring(1, s.length()-1));
+        start++;
+        end--;
+      }
+      else {
+        if (!Character.isLetterOrDigit(s.charAt(start))) {
+          start++;
+        }
+        if (!Character.isLetterOrDigit(s.charAt(end))) {
+          end--;
+        }
+      }
     }
+    return true;
+  }
 }
diff --git a/Medium/Invalid Transactions.java b/Medium/Invalid Transactions.java
new file mode 100644
index 00000000..1d0d9b6d
--- /dev/null
+++ b/Medium/Invalid Transactions.java	
@@ -0,0 +1,46 @@
+class Solution {
+  public List<String> invalidTransactions(String[] transactions) {
+    Map<String, List<Transaction>> map = new HashMap<>();
+    Set<String> invalidTransactions = new HashSet<>();
+    for (int i = 0; i < transactions.length; i++) {
+      String[] details = transactions[i].split(",");
+      String name = details[0];
+      int time = Integer.parseInt(details[1]);
+      int amount = Integer.parseInt(details[2]);
+      String city = details[3];
+      if (amount > 1000) {
+        invalidTransactions.add(transactions[i]);
+      }
+      if (map.containsKey(name)) {
+        List<Transaction> otherTransactions = map.get(name);
+        for (Transaction transaction : otherTransactions) {
+          if (!transaction.city.equals(city) && Math.abs(transaction.time - time) <= 60) {
+            invalidTransactions.add(transactions[transaction.idx]);
+            invalidTransactions.add(transactions[i]);
+          }
+        }
+      }
+      map.computeIfAbsent(name, k -> new ArrayList<>()).add(
+        new Transaction(name, time, amount, city, i)
+      );
+    }
+    return new ArrayList<>(invalidTransactions);
+  }
+}
+
+
+class Transaction {
+  String name;
+  int time;
+  int amount;
+  String city;
+  int idx;
+  
+  public Transaction(String name, int time, int amount, String city, int idx) {
+    this.name = name;
+    this.time = time;
+    this.amount = amount;
+    this.city = city;
+    this.idx = idx;
+  }
+}
diff --git a/Medium/Last Stone Weight II.java b/Medium/Last Stone Weight II.java
new file mode 100644
index 00000000..73764b86
--- /dev/null
+++ b/Medium/Last Stone Weight II.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int lastStoneWeightII(int[] stones) {
+    boolean[] dp = new boolean[1501];
+    dp[0] = true;
+    int sum = 0;
+    for (int stone : stones) {
+      sum += stone;
+      for (int i = Math.min(1500, sum); i >= stone; i--) {
+        dp[i] |= dp[i - stone]; 
+      }
+    }
+    for (int i = sum / 2; i >= 0; i--) {
+      if (dp[i]) {
+        return sum - i - i;
+      }
+    }
+    return 0;
+  }
+}
diff --git a/Medium/Time Based Key-Value Store.java b/Medium/Time Based Key-Value Store.java
index 8f193508..d89b9c65 100644
--- a/Medium/Time Based Key-Value Store.java	
+++ b/Medium/Time Based Key-Value Store.java	
@@ -1,51 +1,30 @@
 class TimeMap {
 
-    /** Initialize your data structure here. */
-    Map<String, List<Entry>> map;
-    public TimeMap() {
-        map = new HashMap<>();
+  /** Initialize your data structure here. */
+  Map<String, TreeMap<Integer, String>> map;
+  public TimeMap() {
+    map = new HashMap<>();
+  }
+
+  public void set(String key, String value, int timestamp) {
+    if (!map.containsKey(key)) {
+      TreeMap<Integer, String> tMap = new TreeMap<>();
+      map.put(key, tMap);
     }
+    map.get(key).put(timestamp, value);
+  }
 
-    public void set(String key, String value, int timestamp) {
-        map.computeIfAbsent(key, k -> new ArrayList<>()).add(new Entry(value, timestamp));
+  public String get(String key, int timestamp) {
+    if (!map.containsKey(key)) {
+      return "";
     }
-
-    public String get(String key, int timestamp) {
-        if (!map.containsKey(key)) {
-            return "";
-        }
-
-        return binarySearch(map.get(key), 0, map.get(key).size() - 1, timestamp);
-    }
-
-    private String binarySearch(List<Entry> entries, int left, int right, int timestamp) {
-        int idx = Integer.MIN_VALUE;
-        while (left <= right) {
-            int mid = (left + right) / 2;
-            if (entries.get(mid).timestamp == timestamp) {
-                return entries.get(mid).value;
-            }
-            else if (entries.get(mid).timestamp > timestamp) {
-                right = mid - 1;
-            }
-            else {
-                idx = Math.max(idx, mid);
-                left = mid + 1;
-            }
-        }
-        
-        return idx == Integer.MIN_VALUE ? "" : entries.get(idx).value;
-    }
-}
-
-class Entry {
-    String value;
-    int timestamp;
-
-    public Entry(String value, int timestamp) {
-        this.value = value;
-        this.timestamp = timestamp;
+    TreeMap<Integer, String> tMap = map.get(key);
+    Integer lower = tMap.floorKey(timestamp);
+    if (lower == null) {
+      return "";
     }
+    return tMap.get(lower);
+  }
 }
 
 /**
diff --git a/Medium/Word Search.java b/Medium/Word Search.java
index 3aa0d784..f5ed8288 100644
--- a/Medium/Word Search.java	
+++ b/Medium/Word Search.java	
@@ -1,36 +1,33 @@
 class Solution {
-  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
   public boolean exist(char[][] board, String word) {
-    int rows = board.length;
-    int cols = board[0].length;
-    for (int i = 0; i < rows; i++) {
-      for (int j = 0; j < cols; j++) {
-        if (dfs(board, i, j, word, 0, new boolean[rows][cols], rows, cols)) {
+    if (board.length == 0 || board[0].length == 0) {
+      return false;
+    }
+    for (int i = 0; i < board.length; i++) {
+      for (int j = 0; j < board[0].length; j++) {
+        if (exists(board, i, j, word, 0, new boolean[board.length][board[0].length])) {
           return true;
         }
       }
     }
     return false;
-  }
+  } 
   
-  private boolean dfs(char[][] board, int x, int y, String s, int idx, 
-                      boolean[][] visited, int rows, int cols) {
-    if (idx == s.length()) {
+  private boolean exists(char[][] board, int i, int j, String word, int idx, boolean[][] visited) {
+    if (idx == word.length()) {
       return true;
     }
-    if (x < 0 || x >= rows || y < 0 || y >= cols || visited[x][y]) {
-      return false;
-    }
-    if (s.charAt(idx) != board[x][y]) {
+    if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || visited[i][j] || word.charAt(idx) != board[i][j]) {
       return false;
     }
-    visited[x][y] = true;
+    visited[i][j] = true;
     for (int[] dir : dirs) {
-      if (dfs(board, x + dir[0], y + dir[1], s, idx + 1, visited, rows, cols)) {
+      if (exists(board, i + dir[0], j + dir[1], word, idx + 1, visited)) {
         return true;
       }
     }
-    visited[x][y] = false;
+    visited[i][j] = false;
     return false;
   }
 }

From e72aac2190ad7364904d06a72b84ac7c7288386f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 21 Jul 2020 16:12:48 -0500
Subject: [PATCH 0238/2175] Added 2 solutions and modified 1 solution

---
 Hard/Subarrays with K Different Integers.java | 29 ++++++++
 Medium/Asteroid Collision.java                | 67 +++++++------------
 ...rings Containing All Three Characters.java | 18 +++++
 3 files changed, 72 insertions(+), 42 deletions(-)
 create mode 100644 Hard/Subarrays with K Different Integers.java
 create mode 100644 Medium/Number of Substrings Containing All Three Characters.java

diff --git a/Hard/Subarrays with K Different Integers.java b/Hard/Subarrays with K Different Integers.java
new file mode 100644
index 00000000..42224709
--- /dev/null
+++ b/Hard/Subarrays with K Different Integers.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int subarraysWithKDistinct(int[] A, int K) {
+    return atMostK(A, K) - atMostK(A, K - 1);
+  }
+  
+  private int atMostK(int[] A, int K) {
+    int start = 0;
+    int end = 0;
+    int n = A.length;
+    Map<Integer, Integer> map = new HashMap<>();
+    int count = 0;
+    while (end < n) {
+      if (map.getOrDefault(A[end], 0) == 0) {
+        K--;
+      }
+      map.put(A[end], map.getOrDefault(A[end], 0) + 1);
+      while (K < 0) {
+        map.put(A[start], map.getOrDefault(A[start], 0) - 1);
+        if (map.get(A[start]) == 0) {
+          K++;
+        }
+        start++;
+      }
+      count += end - start + 1;
+      end++;
+    }
+    return count;
+  }
+}
diff --git a/Medium/Asteroid Collision.java b/Medium/Asteroid Collision.java
index cfae942f..dc8ca9bf 100644
--- a/Medium/Asteroid Collision.java	
+++ b/Medium/Asteroid Collision.java	
@@ -1,46 +1,29 @@
 class Solution {
-    public int[] asteroidCollision(int[] asteroids) {
-        int[] ans;
-        int i = 0;
-        Stack<Integer> stack = new Stack<>();
-
-        while (i < asteroids.length) {
-            if (stack.isEmpty()) {
-                stack.push(asteroids[i]);
-            }
-            else if (asteroids[i] < 0) {
-                if (stack.peek() > 0) {
-                    int temp = stack.pop();
-                    if (temp > Math.abs(asteroids[i])) {
-                        stack.push(temp);
-                    }
-                    else if (temp == Math.abs(asteroids[i])) {
-                        i++;
-                        continue;
-                    }
-                    else {
-                        continue;
-                    }
-                }
-                else {
-                    stack.push(asteroids[i]);
-                }
-            }
-            else {
-                stack.push(asteroids[i]);
-            }
-
-            i++;
+  public int[] asteroidCollision(int[] asteroids) {
+    Stack<Integer> stack = new Stack<>();
+    for (int asteroid : asteroids) {
+      boolean toAdd = true;
+      if (asteroid < 0) {
+        while (!stack.isEmpty() && stack.peek() > 0) {
+          if (Math.abs(asteroid) > stack.peek()) {
+            stack.pop();
+            continue;
+          }
+          else if (Math.abs(asteroid) == stack.peek()) {
+            stack.pop();
+          }
+          toAdd = false;
+          break;
         }
-
-        ans = new int[stack.size()];
-        i = stack.size()-1;
-
-        while (i >= 0) {
-            ans[i] = stack.pop();
-            i--;
-        }
-
-        return ans;
+      }
+      if (toAdd) {
+        stack.push(asteroid);
+      }
+    }
+    int[] ans = new int[stack.size()];
+    for (int i = ans.length - 1; i >= 0; i--) {
+      ans[i] = stack.pop();
     }
+    return ans;
+  }
 }
diff --git a/Medium/Number of Substrings Containing All Three Characters.java b/Medium/Number of Substrings Containing All Three Characters.java
new file mode 100644
index 00000000..c3e5460c
--- /dev/null
+++ b/Medium/Number of Substrings Containing All Three Characters.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int numberOfSubstrings(String s) {
+    int ans = 0;
+    int[] count = new int[3];
+    int start = 0;
+    int end = 0;
+    int n = s.length();
+    while (end < n) {
+      count[s.charAt(end) - 'a']++;
+      while (count[0] > 0 && count[1] > 0 && count[2] > 0) {
+        count[s.charAt(start++) - 'a']--;
+      }
+      end++;
+      ans += start;
+    }
+    return ans;
+  }
+}

From 74a38e78d20a505610377ebaab4ba42ff7c73a48 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 22 Jul 2020 09:47:55 -0500
Subject: [PATCH 0239/2175] Added 1 solution & modified 3 solutions

---
 ... from Inorder and Postorder Traversal.java | 57 +++++++--------
 ...rings Containing All Three Characters.java | 19 ++---
 Medium/Permutation in String.java             | 46 ++++++------
 ...Shortest Path with Alternating Colors.java | 72 +++++++++++++++++++
 4 files changed, 124 insertions(+), 70 deletions(-)
 create mode 100644 Medium/Shortest Path with Alternating Colors.java

diff --git a/Medium/Construct Binary Tree from Inorder and Postorder Traversal.java b/Medium/Construct Binary Tree from Inorder and Postorder Traversal.java
index aef2c5d3..9e69f9f5 100644
--- a/Medium/Construct Binary Tree from Inorder and Postorder Traversal.java	
+++ b/Medium/Construct Binary Tree from Inorder and Postorder Traversal.java	
@@ -4,41 +4,34 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode buildTree(int[] inorder, int[] postorder) { 
-        if (postorder.length == 0) {
-            return null;
-        }
-        
-        TreeNode root = constructTree(inorder, 0, inorder.length - 1, postorder, postorder.length-1);
-        
-        return root;
+  int idx;
+  public TreeNode buildTree(int[] inorder, int[] postorder) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < inorder.length; i++) {
+      map.put(inorder[i], i);
     }
-    
-    private TreeNode constructTree(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart) {
-        if (inStart > inEnd) {
-            return null;
-        }
-        
-        int idx = getIndex(inorder, postorder[postStart], inStart, inEnd);
-
-        TreeNode node = new TreeNode(inorder[idx]);
-        node.left = constructTree(inorder, inStart, idx - 1, postorder, postStart-(inEnd - idx) - 1);
-        node.right = constructTree(inorder, idx + 1, inEnd, postorder, postStart-1);
-        
-        return node;
-    }
-    
-    private int getIndex(int[] arr, int num, int start, int end) {
-        for (int i=start; i<=end; i++) {
-            if (arr[i] == num) {
-                return i;
-            }
-        }
-        
-        return -1;
+    idx = postorder.length - 1;
+    return helper(inorder, postorder, 0, postorder.length - 1, map);
+  }
+  
+  private TreeNode helper(int[] inorder, int[] postorder, int start, int end, Map<Integer, Integer> map) {
+    if (start > end) {
+      return null;
     }
+    TreeNode node = new TreeNode(postorder[idx]);
+    int pos = map.get(postorder[idx--]);
+    node.right = helper(inorder, postorder, pos + 1, end, map);
+    node.left = helper(inorder, postorder, start, pos - 1, map);
+    return node;
+  }
 }
diff --git a/Medium/Number of Substrings Containing All Three Characters.java b/Medium/Number of Substrings Containing All Three Characters.java
index c3e5460c..41f9141d 100644
--- a/Medium/Number of Substrings Containing All Three Characters.java	
+++ b/Medium/Number of Substrings Containing All Three Characters.java	
@@ -1,18 +1,13 @@
 class Solution {
   public int numberOfSubstrings(String s) {
-    int ans = 0;
-    int[] count = new int[3];
-    int start = 0;
-    int end = 0;
-    int n = s.length();
-    while (end < n) {
-      count[s.charAt(end) - 'a']++;
-      while (count[0] > 0 && count[1] > 0 && count[2] > 0) {
-        count[s.charAt(start++) - 'a']--;
+    int[] indexes = new int[]{-1, -1, -1};
+    int count = 0;
+    for (int i = 0; i < s.length(); i++) {
+      indexes[s.charAt(i) - 'a'] = i;
+      if (indexes[0] != -1 && indexes[1] != -1 && indexes[2] != -1) {
+        count += Math.min(indexes[0], Math.min(indexes[1], indexes[2])) + 1;
       }
-      end++;
-      ans += start;
     }
-    return ans;
+    return count;
   }
 }
diff --git a/Medium/Permutation in String.java b/Medium/Permutation in String.java
index ca89a82f..e405a988 100644
--- a/Medium/Permutation in String.java	
+++ b/Medium/Permutation in String.java	
@@ -1,31 +1,25 @@
 class Solution {
-    public boolean checkInclusion(String s1, String s2) {
-        int l1 = s1.length();
-        int l2 = s2.length();
-        if (l1 > l2) return false;
-        
-        int[] check = new int[26];
-        
-        for (int i=0;i<l1;i++) {
-            check[s1.charAt(i)-'a']++;
-            check[s2.charAt(i)-'a']--;
-        }
-        
-        if (zeroArr(check)) return true;
-        
-        for (int i = l1; i < l2; i++) {
-            check[s2.charAt(i) - 'a']--;
-            check[s2.charAt(i - l1) - 'a']++;
-            if (zeroArr(check)) return true;
-        }
-        
-        return false;
+  public boolean checkInclusion(String s1, String s2) {
+    if (s1.length() > s2.length()) {
+      return false;
     }
-    
-    boolean zeroArr(int[] arr) {
-        for (int i=0;i<26;i++) {
-            if (arr[i] != 0) return false;
-        }
+    int[] counter = new int[26];
+    for (char c : s1.toCharArray()) {
+      counter[c - 'a']++;
+    }
+    String targetStr = Arrays.toString(counter);
+    int[] targetCounter = new int[26];
+    for (int i = 0; i < s1.length() - 1; i++) {
+      targetCounter[s2.charAt(i) - 'a']++;
+    }
+    int start = 0;
+    for (int i = s1.length() - 1; i < s2.length(); i++) {
+      targetCounter[s2.charAt(i) - 'a']++;
+      if (Arrays.toString(targetCounter).equals(targetStr)) {
         return true;
+      }
+      targetCounter[s2.charAt(start++) - 'a']--;
     }
+    return false;
+  }
 }
diff --git a/Medium/Shortest Path with Alternating Colors.java b/Medium/Shortest Path with Alternating Colors.java
new file mode 100644
index 00000000..c2c3622a
--- /dev/null
+++ b/Medium/Shortest Path with Alternating Colors.java	
@@ -0,0 +1,72 @@
+class Solution {
+  private final Integer RED = 1;
+  private final Integer BLUE = 2;
+  public int[] shortestAlternatingPaths(int n, int[][] red_edges, int[][] blue_edges) {
+    Map<Integer, List<Connection>> map = new HashMap<>();
+    for (int[] edge : red_edges) {
+      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], RED));
+    }
+    for (int[] edge : blue_edges) {
+      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], BLUE));
+    }
+    int[] distances = new int[n];
+    for (int i = 1; i < n; i++) {
+      distances[i] = getDistance(map, i, n);
+    }
+    return distances;
+  }
+  
+  private int getDistance(Map<Integer, List<Connection>> map, int target, int n) {
+    int curr = 0;
+    int steps = 0;
+    boolean found = false;
+    Queue<int[]> queue = new LinkedList<>();
+    boolean[][] visited = new boolean[2][n];
+    queue.add(new int[]{0, -1});
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int[] removed = queue.remove();
+        if (removed[0] == target) {
+          found = true;
+          break;
+        }
+        int color = removed[1];
+        for (Connection connection : map.getOrDefault(removed[0], new ArrayList<>())) {
+          if (color == -1 && !visited[connection.color - 1][connection.val]) {
+            visited[connection.color - 1][connection.val] = true;
+            queue.add(connection.getArray());
+          }
+          else if (color == 1 && connection.color != 1 && !visited[connection.color - 1][connection.val]) {
+            visited[connection.color - 1][connection.val] = true;
+            queue.add(connection.getArray());
+          }
+          else if (color == 2 && connection.color != 2 && !visited[connection.color - 1][connection.val]) {
+            visited[connection.color - 1][connection.val] = true;
+            queue.add(connection.getArray());
+          }
+        }
+      }
+      if (found) {
+        break;
+      }
+      steps++;
+    }
+    return found ? steps : -1;
+  }
+}
+
+
+class Connection {
+  int val;
+  int color;
+  
+  public Connection(int val, int color) {
+    this.val = val;
+    this.color = color;
+  }
+  
+  public int[] getArray() {
+    return new int[]{this.val, this.color};
+  }
+}

From 504cb717a49096e9a7bc406239221a435d36b4d2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 22 Jul 2020 12:25:20 -0500
Subject: [PATCH 0240/2175] Added 1 solution & modified 5 solutions

---
 Easy/Employee Importance.java                 | 24 +++++----
 Easy/First Bad Version.java                   | 14 +++---
 Easy/Guess Number Higher or Lower.java        | 44 +++++++++--------
 Easy/Invert Binary Tree.java                  | 28 +++++++++++
 Easy/Invert a binary tree.java                | 22 ---------
 Easy/Remove Duplicates from Sorted Array.java | 15 ++++++
 Easy/remove_duplicates_sorted.java            | 21 --------
 Hard/Candy.java                               | 48 ++++++++----------
 Medium/Snapshot Array.java                    | 49 +++++++------------
 9 files changed, 124 insertions(+), 141 deletions(-)
 create mode 100644 Easy/Invert Binary Tree.java
 delete mode 100644 Easy/Invert a binary tree.java
 create mode 100644 Easy/Remove Duplicates from Sorted Array.java
 delete mode 100644 Easy/remove_duplicates_sorted.java

diff --git a/Easy/Employee Importance.java b/Easy/Employee Importance.java
index 9a1a046e..03bf2cc2 100644
--- a/Easy/Employee Importance.java	
+++ b/Easy/Employee Importance.java	
@@ -1,29 +1,27 @@
 /*
-// Employee info
+// Definition for Employee.
 class Employee {
-    // It's the unique id of each node;
-    // unique id of this employee
     public int id;
-    // the importance value of this employee
     public int importance;
-    // the id of direct subordinates
     public List<Integer> subordinates;
 };
 */
+
 class Solution {
   public int getImportance(List<Employee> employees, int id) {
     Map<Integer, Employee> map = new HashMap<>();
     for (Employee employee : employees) {
       map.put(employee.id, employee);
     }
-    return dfs(map, id);
-  }
-  
-  private int dfs(Map<Integer, Employee> map, int id) {
-    Employee employee = map.get(id);
-    int importance = employee.importance;
-    for (Integer sub : employee.subordinates) {
-      importance += dfs(map, sub);
+    int importance = 0;
+    Queue<Employee> queue = new LinkedList<>();
+    queue.add(map.get(id));
+    while (!queue.isEmpty()) {
+      Employee removed = queue.remove();
+      importance += removed.importance;
+      for (Integer subordinate : removed.subordinates) {
+        queue.add(map.get(subordinate));
+      }
     }
     return importance;
   }
diff --git a/Easy/First Bad Version.java b/Easy/First Bad Version.java
index 04e7c14b..649a6430 100644
--- a/Easy/First Bad Version.java	
+++ b/Easy/First Bad Version.java	
@@ -3,20 +3,22 @@
 
 public class Solution extends VersionControl {
   public int firstBadVersion(int n) {
+    if (n == 1) {
+      return 1;
+    }
     int start = 1;
     int end = n;
-    while (start < end) {
+    int minIdx = Integer.MAX_VALUE;
+    while (start <= end) {
       int mid = start + (end - start) / 2;
       if (isBadVersion(mid)) {
-        if (mid == 1 || isBadVersion(mid - 1) == false) {
-          return mid;
-        }
+        minIdx = Math.min(minIdx, mid);
         end = mid - 1;
       }
       else {
         start = mid + 1;
       }
     }
-    return start;
-  } 
+    return minIdx;
+  }
 }
diff --git a/Easy/Guess Number Higher or Lower.java b/Easy/Guess Number Higher or Lower.java
index 36b0fa0d..e10f90ab 100644
--- a/Easy/Guess Number Higher or Lower.java	
+++ b/Easy/Guess Number Higher or Lower.java	
@@ -1,25 +1,29 @@
-/* The guess API is defined in the parent class GuessGame.
-   @param num, your guess
-   @return -1 if my number is lower, 1 if my number is higher, otherwise return 0
-      int guess(int num); */
+/** 
+ * Forward declaration of guess API.
+ * @param  num   your guess
+ * @return 	     -1 if num is lower than the guess number
+ *			      1 if num is higher than the guess number
+ *               otherwise return 0
+ * int guess(int num);
+ */
 
 public class Solution extends GuessGame {
-    public int guessNumber(int n) {
-        int start = 1;
-        int end = n;
-        int mid = -1;
-        while (true) {
-            mid = start + (end-start)/2;
-            if (guess(mid) == -1) {
-                end = mid-1;
-            }
-            else if (guess(mid) == 1) {
-                start = mid+1;
-            }
-            else {
-                break;
-            }
-        }
+  public int guessNumber(int n) {
+    int start = 1;
+    int end = n;
+    while (start <= end) {
+      int mid = start + (end - start) / 2;
+      int res = guess(mid);
+      if (res == 0) {
         return mid;
+      }
+      else if (res == -1) {
+        end = mid - 1;
+      }
+      else {
+        start = mid + 1;
+      }
     }
+    return -1;
+  }
 }
diff --git a/Easy/Invert Binary Tree.java b/Easy/Invert Binary Tree.java
new file mode 100644
index 00000000..f02950d0
--- /dev/null
+++ b/Easy/Invert Binary Tree.java	
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode invertTree(TreeNode root) {
+    if (root == null) {
+      return root;
+    }
+    TreeNode right = root.right;
+    root.right = root.left;
+    root.left = right;
+    invertTree(root.left);
+    invertTree(root.right);
+    return root;
+  }
+}
diff --git a/Easy/Invert a binary tree.java b/Easy/Invert a binary tree.java
deleted file mode 100644
index 15a9dc3d..00000000
--- a/Easy/Invert a binary tree.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public TreeNode invertTree(TreeNode root) {
-        if (root == null) return null;
-        
-        TreeNode right = invertTree(root.right);
-        TreeNode left = invertTree(root.left);
-        
-        root.right = left;
-        root.left = right;
-        
-        return root;
-    }
-}
diff --git a/Easy/Remove Duplicates from Sorted Array.java b/Easy/Remove Duplicates from Sorted Array.java
new file mode 100644
index 00000000..7349f2f2
--- /dev/null
+++ b/Easy/Remove Duplicates from Sorted Array.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int removeDuplicates(int[] nums) {
+    int start = 0;
+    int end = 0;
+    int n = nums.length;
+    while (end < n) {
+      int curr = nums[end];
+      while (end < n && nums[end] == curr) {
+        end++;
+      }
+      nums[start++] = curr;
+    }
+    return start;
+  }
+}
diff --git a/Easy/remove_duplicates_sorted.java b/Easy/remove_duplicates_sorted.java
deleted file mode 100644
index 2b157cbb..00000000
--- a/Easy/remove_duplicates_sorted.java
+++ /dev/null
@@ -1,21 +0,0 @@
-public class Solution {
-    public static int removeDuplicates(int[] A) {
-	if (A.length < 2)
-		return A.length;
- 
-	int j = 0;
-	int i = 1;
- 
-	while (i < A.length) {
-		if (A[i] == A[j]) {
-			i++;
-		} else {
-			j++;
-			A[j] = A[i];
-			i++;
-		}
-	}
- 
-	return j + 1;
-    }
-}
\ No newline at end of file
diff --git a/Hard/Candy.java b/Hard/Candy.java
index afb4ecda..ed787668 100644
--- a/Hard/Candy.java
+++ b/Hard/Candy.java
@@ -1,31 +1,23 @@
 class Solution {
-    public int candy(int[] ratings) {
-        if (ratings.length <= 1) {
-            return ratings.length;
-        }
-        
-        int[] candies = new int[ratings.length];
-        for (int i = 0; i < ratings.length; i++) {
-            candies[i] = 1;
-        }
-        
-        for (int i = 1; i < ratings.length; i++) {
-            if (ratings[i] > ratings[i - 1]) {
-                candies[i] = candies[i - 1] + 1;
-            }
-        }
-        
-        for (int i = ratings.length - 1; i > 0; i--) {
-            if (ratings[i - 1] > ratings[i]) {
-                candies[i - 1] = Math.max(candies[i] + 1, candies[i - 1]);
-            }
-        }
-        
-        int candyCount = 0;
-        for (int candy : candies) {
-            candyCount += candy;
-        }
-        
-        return candyCount;
+  public int candy(int[] ratings) {
+    int[] leftCandy = new int[ratings.length];
+    int[] rightCandy = new int[ratings.length];
+    Arrays.fill(leftCandy, 1);
+    Arrays.fill(rightCandy, 1);
+    for (int i = 1; i < ratings.length; i++) {
+      if (ratings[i] > ratings[i - 1]) {
+        leftCandy[i] = leftCandy[i - 1] + 1;
+      }
     }
+    for (int i = ratings.length - 2; i >= 0; i--) {
+      if (ratings[i] > ratings[i + 1]) {
+        rightCandy[i] = rightCandy[i + 1] + 1;
+      }
+    }
+    int numOfCandies = 0;
+    for (int i = 0; i < ratings.length; i++) {
+      numOfCandies += Math.max(leftCandy[i], rightCandy[i]);
+    }
+    return numOfCandies; 
+  }
 }
diff --git a/Medium/Snapshot Array.java b/Medium/Snapshot Array.java
index 9459d694..d735dde3 100644
--- a/Medium/Snapshot Array.java	
+++ b/Medium/Snapshot Array.java	
@@ -1,39 +1,26 @@
 class SnapshotArray {
-
-    int[] arr;
-    Map<Integer, Map<Integer, Integer>> map;
-    int count;
-    Map<Integer, Integer> temp;
-    public SnapshotArray(int length) {
-        arr = new int[length];
-        map = new HashMap<>();
-        count = 0;
-        temp = new HashMap<>();
-    }
-
-    public void set(int index, int val) {
-        arr[index] = val;
-        temp.put(index, val);
+  TreeMap<Integer, Integer>[] A;
+  int snapId;
+  public SnapshotArray(int length) {
+    A = new TreeMap[length];
+    snapId = 0;
+    for (int i = 0; i < length; i++) {
+      A[i] = new TreeMap<Integer, Integer>();
+      A[i].put(0, 0);
     }
+  }
 
-    public int snap() {
-        map.put(count, new HashMap<>(temp));
-        int snapCount = count++;
-        temp = new HashMap<>();
-        return snapCount;
-    }
-
-    public int get(int index, int snap_id) {
-        while (snap_id >= 0) {
-            if (map.get(snap_id).containsKey(index)) {
-                return map.get(snap_id).get(index);
-            }
+  public void set(int index, int val) {
+    A[index].put(snapId, val);
+  }
 
-            snap_id--;
-        }
+  public int snap() {
+    return snapId++;
+  }
 
-        return 0;
-    }
+  public int get(int index, int snap_id) {
+    return A[index].floorEntry(snap_id).getValue();
+  }
 }
 
 /**

From 23195987bd1809094e462c9eb24c2031c58b38e1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 22 Jul 2020 19:19:42 -0500
Subject: [PATCH 0241/2175] Modified 4 solutions

---
 Easy/Fixed Point.java              | 33 ++++++-----
 Medium/Construct Quad Tree.java    | 93 +++++++++++++++++++-----------
 Medium/Design Phone Directory.java | 63 ++++++++++----------
 Medium/Wiggle Sort.java            | 46 ++++++---------
 4 files changed, 126 insertions(+), 109 deletions(-)

diff --git a/Easy/Fixed Point.java b/Easy/Fixed Point.java
index e1dd818d..c2ac5a56 100644
--- a/Easy/Fixed Point.java	
+++ b/Easy/Fixed Point.java	
@@ -1,18 +1,21 @@
 class Solution {
-    public int fixedPoint(int[] A) {
-        int low = 0;
-        int high = A.length - 1;
-        
-        while (low < high) {
-            int mid = (low + high) / 2;
-            if (A[mid] - mid < 0) {
-                low = mid + 1;
-            }
-            else {
-                high = mid;
-            }
-        }
-        
-        return low == A[low] ? low : -1;
+  public int fixedPoint(int[] A) {
+    int start = 0;
+    int end = A.length - 1;
+    int minIdx = Integer.MAX_VALUE;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (A[mid] == mid) {
+        minIdx = Math.min(minIdx, mid);
+        end = mid - 1;
+      }
+      else if (A[mid] > mid) {
+        end = mid - 1;
+      }
+      else {
+        start = mid + 1;
+      }
     }
+    return minIdx == Integer.MAX_VALUE ? -1 : minIdx;
+  }
 }
diff --git a/Medium/Construct Quad Tree.java b/Medium/Construct Quad Tree.java
index c9df19ec..c9aa0f6e 100644
--- a/Medium/Construct Quad Tree.java	
+++ b/Medium/Construct Quad Tree.java	
@@ -8,45 +8,68 @@ class Node {
     public Node bottomLeft;
     public Node bottomRight;
 
-    public Node() {}
-
-    public Node(boolean _val,boolean _isLeaf,Node _topLeft,Node _topRight,Node _bottomLeft,Node _bottomRight) {
-        val = _val;
-        isLeaf = _isLeaf;
-        topLeft = _topLeft;
-        topRight = _topRight;
-        bottomLeft = _bottomLeft;
-        bottomRight = _bottomRight;
+    
+    public Node() {
+        this.val = false;
+        this.isLeaf = false;
+        this.topLeft = null;
+        this.topRight = null;
+        this.bottomLeft = null;
+        this.bottomRight = null;
+    }
+    
+    public Node(boolean val, boolean isLeaf) {
+        this.val = val;
+        this.isLeaf = isLeaf;
+        this.topLeft = null;
+        this.topRight = null;
+        this.bottomLeft = null;
+        this.bottomRight = null;
+    }
+    
+    public Node(boolean val, boolean isLeaf, Node topLeft, Node topRight, Node bottomLeft, Node bottomRight) {
+        this.val = val;
+        this.isLeaf = isLeaf;
+        this.topLeft = topLeft;
+        this.topRight = topRight;
+        this.bottomLeft = bottomLeft;
+        this.bottomRight = bottomRight;
     }
 };
 */
+
 class Solution {
-    public Node construct(int[][] grid) {
-        return helper(grid, 0, 0, grid.length);
+  public Node construct(int[][] grid) {
+    return helper(grid, 0, 0, grid.length);
+  }
+  
+  private Node helper(int[][] grid, int x, int y, int len) {
+    if (len == 1) {
+      return new Node(grid[x][y] != 0, true, null, null, null, null);
     }
-    
-    private Node helper(int[][] grid, int x, int y, int len) {
-        if (len == 1) {
-            return new Node(grid[x][y] != 0, true, null, null, null, null);
-        }
-        
-        Node result = new Node();
-        Node topLeft = helper(grid, x, y, len / 2);
-        Node topRight = helper(grid, x, y + len / 2, len / 2);
-        Node bottomLeft = helper(grid, x + len / 2, y, len / 2);
-        Node bottomRight = helper(grid, x + len / 2, y + len / 2, len / 2);
-        
-        if (topLeft.isLeaf && topRight.isLeaf && bottomLeft.isLeaf && bottomRight.isLeaf
-           && topLeft.val == topRight.val && topRight.val == bottomLeft.val && bottomLeft.val == bottomRight.val) {
-            result.isLeaf = true;
-            result.val = topLeft.val;
-        } else {
-            result.topLeft = topLeft;
-            result.topRight = topRight;
-            result.bottomLeft = bottomLeft;
-            result.bottomRight = bottomRight;
-        }
-        
-        return result;
+    Node result = new Node();
+    Node topLeft = helper(grid, x, y, len / 2);
+    Node topRight = helper(grid, x, y + len / 2, len / 2);
+    Node bottomLeft = helper(grid, x + len / 2, y, len / 2);
+    Node bottomRight = helper(grid, x + len / 2, y + len / 2, len / 2);
+    if (
+      topLeft.isLeaf && 
+      topRight.isLeaf && 
+      bottomLeft.isLeaf && 
+      bottomRight.isLeaf && 
+      topLeft.val == topRight.val && 
+      topRight.val == bottomLeft.val && 
+      bottomLeft.val == bottomRight.val
+    ) {
+      result.isLeaf = true;
+      result.val = topLeft.val;
+    } 
+    else {
+      result.topLeft = topLeft;
+      result.topRight = topRight;
+      result.bottomLeft = bottomLeft;
+      result.bottomRight = bottomRight;
     }
+    return result;
+  }
 }
diff --git a/Medium/Design Phone Directory.java b/Medium/Design Phone Directory.java
index 2ee6f1ef..137153dd 100644
--- a/Medium/Design Phone Directory.java	
+++ b/Medium/Design Phone Directory.java	
@@ -1,43 +1,42 @@
 class PhoneDirectory {
 
-    /** Initialize your data structure here
-     @param maxNumbers - The maximum numbers that can be stored in the phone directory. */
-    int[] directory;
-    int pos;
-    public PhoneDirectory(int maxNumbers) {
-        directory = new int[maxNumbers];
-        for (int i=0; i<maxNumbers; i++) {
-            directory[i] = (i+1)%maxNumbers;
-        }
-        pos = 0;
+  /** Initialize your data structure here
+      @param maxNumbers - The maximum numbers that can be stored in the phone directory. */
+  int[] directory;
+  int position;
+  public PhoneDirectory(int maxNumbers) {
+    directory = new int[maxNumbers];
+    for (int i = 0; i < maxNumbers; i++) {
+      directory[i] = (i + 1) % maxNumbers;
     }
+    position = 0;
+  }
 
-    /** Provide a number which is not assigned to anyone.
-     @return - Return an available number. Return -1 if none is available. */
-    public int get() {
-        if (directory[pos] == -1) {
-            return -1;
-        }
-
-        int val = pos;
-        pos = directory[pos];
-        directory[val] = -1;
-        return val;
+  /** Provide a number which is not assigned to anyone.
+      @return - Return an available number. Return -1 if none is available. */
+  public int get() {
+    if (directory[position] == -1) {
+      return -1;
     }
+    int value = position;
+    position = directory[position];
+    directory[value] = -1;
+    return value;
+  }
 
-    /** Check if a number is available or not. */
-    public boolean check(int number) {
-        return directory[number] != -1;
-    }
+  /** Check if a number is available or not. */
+  public boolean check(int number) {
+    return directory[number] != -1;
+  }
 
-    /** Recycle or release a number. */
-    public void release(int number) {
-        if (directory[number] != -1) {
-            return;
-        }
-        directory[number] = pos;
-        pos = number;
+  /** Recycle or release a number. */
+  public void release(int number) {
+    if (directory[number] != -1) {
+      return;
     }
+    directory[number] = position;
+    position = number;
+  }
 }
 
 /**
diff --git a/Medium/Wiggle Sort.java b/Medium/Wiggle Sort.java
index 56acbb46..e4e8ad13 100644
--- a/Medium/Wiggle Sort.java	
+++ b/Medium/Wiggle Sort.java	
@@ -1,32 +1,24 @@
 class Solution {
-    public void wiggleSort(int[] nums) {
-        if (nums.length <= 1) {
-            return;
+  public void wiggleSort(int[] nums) {
+    boolean small = true;
+    for (int i = 0; i < nums.length - 1; i++) {
+      if (small) {
+        if (nums[i] > nums[i + 1]) {
+          swap(nums, i, i + 1);
         }
-
-        if (nums.length == 2) {
-            if (nums[0] > nums[1]) {
-                swap(nums, 0, 1);
-            }
+      }
+      else {
+        if (nums[i] < nums[i + 1]) {
+          swap(nums, i, i + 1);
         }
-
-        int i=0;
-        while (i < nums.length) {
-            if (i+1 < nums.length && nums[i] > nums[i+1]) {
-                swap(nums, i, i+1);
-            }
-
-            if (i+1 < nums.length && i+2 < nums.length && nums[i+1] <= nums[i+2]) {
-                swap(nums, i+1, i+2);
-            }
-
-            i += 2;
-        }
-    }
-
-    public void swap(int[] nums, int i, int j) {
-        int temp = nums[i];
-        nums[i] = nums[j];
-        nums[j] = temp;
+      }
+      small = !small;
     }
+  }
+  
+  private void swap(int[] nums, int idx1, int idx2) {
+    int temp = nums[idx2];
+    nums[idx2] = nums[idx1];
+    nums[idx1] = temp;
+  }
 }

From cda77c6fcd1204732c3af6f711ef6318550b136b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 23 Jul 2020 10:58:58 -0500
Subject: [PATCH 0242/2175] Modified 4 solutions

---
 Easy/Maximum Subarray.java           | 14 ++--
 Hard/Reverse Nodes in k-Group.java   | 60 +++++++++++++++++
 Medium/Design Tic-Tac-Toe.java       | 99 +++++++++++++++++-----------
 Medium/Reverse Nodes in k-group.java | 32 ---------
 Medium/Single Number III.java        | 41 ++++--------
 5 files changed, 138 insertions(+), 108 deletions(-)
 create mode 100644 Hard/Reverse Nodes in k-Group.java
 delete mode 100644 Medium/Reverse Nodes in k-group.java

diff --git a/Easy/Maximum Subarray.java b/Easy/Maximum Subarray.java
index 0c3667dd..46b106c7 100644
--- a/Easy/Maximum Subarray.java	
+++ b/Easy/Maximum Subarray.java	
@@ -1,12 +1,12 @@
 class Solution {
   public int maxSubArray(int[] nums) {
-    if (nums.length == 0) {
-      return 0;
-    }
-    int currSum = nums[0];
-    int maxSum = currSum;
-    for (int i = 1; i < nums.length; i++) {
-      currSum = Math.max(currSum + nums[i], nums[i]);
+    int currSum = 0;
+    int maxSum = Integer.MIN_VALUE;
+    for (int num : nums) {
+      currSum += num;
+      if (num > currSum) {
+        currSum = num;
+      }
       maxSum = Math.max(maxSum, currSum);
     }
     return maxSum;
diff --git a/Hard/Reverse Nodes in k-Group.java b/Hard/Reverse Nodes in k-Group.java
new file mode 100644
index 00000000..66ab4ec1
--- /dev/null
+++ b/Hard/Reverse Nodes in k-Group.java	
@@ -0,0 +1,60 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode reverseKGroup(ListNode head, int k) {
+    if (head == null) {
+      return null;
+    }
+    ListNode start = head;
+    ListNode curr = head;
+    ListNode prev = null;
+    ListNode revHead = null;
+    while (curr != null) {
+      int count = 1;
+      while (curr.next != null && count < k) {
+        curr = curr.next;
+        count++;
+      }
+      if (count == k) {
+        ListNode next = curr.next;
+        curr.next = null;
+        if (revHead == null) {
+          revHead = curr;
+        }
+        ListNode reverse = reverse(start);
+        if (prev != null) {
+          prev.next = reverse;
+        }
+        start.next = next;
+        prev = start;
+        start = next;
+        curr = next;
+      }
+      else {
+        curr = curr.next;
+      }
+    }
+    return revHead == null ? head : revHead;
+  } 
+  
+  private ListNode reverse(ListNode root) {
+    ListNode curr = root;
+    ListNode next = null;
+    ListNode prev = null;
+    while (curr != null) {
+      next = curr.next;
+      curr.next = prev;
+      prev = curr;
+      curr = next;
+    }
+    return prev;
+  }
+}
diff --git a/Medium/Design Tic-Tac-Toe.java b/Medium/Design Tic-Tac-Toe.java
index 25187bbe..35c3bd4b 100644
--- a/Medium/Design Tic-Tac-Toe.java	
+++ b/Medium/Design Tic-Tac-Toe.java	
@@ -1,48 +1,67 @@
 class TicTacToe {
 
-    /** Initialize your data structure here. */
-    private int[] rows;
-    private int[] cols;
-    private int leftDiagCount;
-    private int rightDiagCount;
-    private int n;
+  /** Initialize your data structure here. */
+  int[][] board;
+  Map<Integer, Map<Integer, Integer>> rowMap;
+  Map<Integer, Map<Integer, Integer>> colMap;
+  Map<Integer, Integer> leftDiagonalMap;
+  Map<Integer, Integer> rightDiagonalMap;
+  int n;
+  public TicTacToe(int n) {
+    board = new int[n][n];
+    rowMap = new HashMap<>();
+    colMap = new HashMap<>();
+    leftDiagonalMap = new HashMap<>();
+    rightDiagonalMap = new HashMap<>();
+    this.n = n;
+  }
 
-    public TicTacToe(int n) {
-        this.n = n;
-        this.rows = new int[n];
-        this.cols = new int[n];
-        leftDiagCount = 0;
-        rightDiagCount = 0;
+  /** Player {player} makes a move at ({row}, {col}).
+      @param row The row of the board.
+      @param col The column of the board.
+      @param player The player, can be either 1 or 2.
+      @return The current winning condition, can be either:
+              0: No one wins.
+              1: Player 1 wins.
+              2: Player 2 wins. */
+  public int move(int row, int col, int player) {
+    if (!rowMap.containsKey(row)) {
+      Map<Integer, Integer> map = new HashMap<>();
+      rowMap.put(row, map);
     }
-
-    /** Player {player} makes a move at ({row}, {col}).
-     @param row The row of the board.
-     @param col The column of the board.
-     @param player The player, can be either 1 or 2.
-     @return The current winning condition, can be either:
-     0: No one wins.
-     1: Player 1 wins.
-     2: Player 2 wins. */
-    public int move(int row, int col, int player) {
-        int moveValue = player == 1 ? 1 : -1;
-        rows[row] += moveValue;
-        cols[col] += moveValue;
-        if (row == col) {
-            leftDiagCount += moveValue;
-        }
-        if (col == n - row - 1) {
-            rightDiagCount += moveValue;
-        }
-        if (
-            Math.abs(rows[row]) == n ||
-            Math.abs(cols[col]) == n ||
-            Math.abs(leftDiagCount) == n || 
-            Math.abs(rightDiagCount) == n
-        ) {
-            return player;
-        }
-        return 0;
+    rowMap.get(row).put(player, rowMap.get(row).getOrDefault(player, 0) + 1);
+    if (ifWinner(rowMap.get(row), player)) {
+      return player;
+    }
+    if (!colMap.containsKey(col)) {
+      Map<Integer, Integer> map = new HashMap<>();
+      colMap.put(col, map);
+    }
+    colMap.get(col).put(player, colMap.get(col).getOrDefault(player, 0) + 1);
+    if (ifWinner(colMap.get(col), player)) {
+      return player;
+    }
+    if (row == col) {
+      leftDiagonalMap.put(player, leftDiagonalMap.getOrDefault(player, 0) + 1);
+    }
+    if (ifWinner(leftDiagonalMap, player)) {
+      return player;
+    }
+    if (row + col == n - 1) {
+      rightDiagonalMap.put(player, rightDiagonalMap.getOrDefault(player, 0) + 1);
+    }
+    if (ifWinner(rightDiagonalMap, player)) {
+      return player;
+    }
+    return 0;
+  }
+  
+  private boolean ifWinner(Map<Integer, Integer> map, int player) {
+    if (map.size() > 1) {
+      return false;
     }
+    return map.values().stream().reduce(0, Integer::sum) == n;
+  }
 }
 
 /**
diff --git a/Medium/Reverse Nodes in k-group.java b/Medium/Reverse Nodes in k-group.java
deleted file mode 100644
index d565c37c..00000000
--- a/Medium/Reverse Nodes in k-group.java	
+++ /dev/null
@@ -1,32 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public ListNode reverseKGroup(ListNode head, int k) {
-        ArrayList<Integer> arr = new ArrayList<>();
-        ListNode curr = head;
-        while (curr != null) {
-            arr.add(curr.val);
-            curr = curr.next;
-        }
-        
-        curr = head;
-        int i = 0;
-        int n = k;
-        while(i+k <= arr.size()) {
-            while(n != 0) {
-                curr.val = arr.get(i+n-1);
-                curr = curr.next;
-                n--;
-            }
-            i += k;
-            n = k;
-        }
-        return head;
-    }
-}
diff --git a/Medium/Single Number III.java b/Medium/Single Number III.java
index f098e747..7caf6b85 100644
--- a/Medium/Single Number III.java	
+++ b/Medium/Single Number III.java	
@@ -1,32 +1,15 @@
 class Solution {
-    public int[] singleNumber(int[] nums) {
-        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
-        
-        for (int i=0;i<nums.length;i++) {
-            if (map.containsKey(nums[i])) {
-                map.put(nums[i], 2);
-            }
-            else {
-                map.put(nums[i], 1);
-            }
-        }
-        
-        int[] ans = new int[2];
-        int j = 0;
-        
-        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            if (entry.getValue() == 1) {
-                if (j == 0) {
-                    ans[j] = entry.getKey();
-                    j++;
-                }
-                else {
-                    ans[j] = entry.getKey();
-                    break;
-                }
-            }
-        }
-        
-        return ans;
+  public int[] singleNumber(int[] nums) {
+    Set<Integer> set = new HashSet<>();
+    for (int num : nums) {
+      if (set.contains(num)) {
+        set.remove(num);
+      }
+      else {
+        set.add(num);
+      }
     }
+    Iterator<Integer> iter = set.iterator();
+    return new int[]{iter.next(), iter.next()};
+  }
 }

From 9ff12b20b9f8c961e95c6ed7907a1ddd4f869a9c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 24 Jul 2020 08:47:29 -0500
Subject: [PATCH 0243/2175] Added 1 solution & modified 3 solutions

---
 Hard/Sliding Window Maximum.java              | 73 +++++-------------
 Medium/Diameter of N-ary Tree.java            | 50 +++++++++++++
 Medium/Find Leaves of Binary Tree.java        | 75 +++++++------------
 ...g Next Right Pointers in Each Node II.java | 55 +++++++-------
 4 files changed, 123 insertions(+), 130 deletions(-)
 create mode 100644 Medium/Diameter of N-ary Tree.java

diff --git a/Hard/Sliding Window Maximum.java b/Hard/Sliding Window Maximum.java
index 1735cafb..c1ae146e 100644
--- a/Hard/Sliding Window Maximum.java	
+++ b/Hard/Sliding Window Maximum.java	
@@ -1,58 +1,23 @@
 class Solution {
-    public static int[] maxSlidingWindowDynamic(int[] nums, int k) {
-        if (nums.length == 0 || nums.length < k) {
-            return new int[]{};
-        }
-        
-        int[] maxLeft = new int[nums.length];
-        int[] maxRight = new int[nums.length];
-
-        maxLeft[0] = nums[0];
-        maxRight[nums.length-1] = nums[nums.length-1];
-
-        for (int i=1; i<nums.length; i++) {
-            maxLeft[i] = i%k == 0 ? nums[i] : Math.max(nums[i], maxLeft[i-1]);
-            int j = nums.length - i - 1;
-            maxRight[j] = j%k == 0 ? nums[j] : Math.max(maxRight[j+1], nums[j]);
-        }
-
-        int[] ans = new int[nums.length - k + 1];
-
-        for (int i=0; i<=nums.length-k; i++) {
-            ans[i] = Math.max(maxRight[i], maxLeft[i + k - 1]);
-        }
-
-        return ans;
+  public int[] maxSlidingWindow(int[] nums, int k) {
+    int n = nums.length;
+    if (n == 0 || k == 0) {
+      return new int[0];
     }
-    
-    public static int[] maxSlidingWindow(int[] nums, int k) {
-        if (nums.length == 0 || nums.length < k) {
-            return new int[]{};
-        }
-
-        int[] ans = new int[nums.length-k+1];
-        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
-            @Override
-            public int compare(Integer o1, Integer o2) {
-                return o2 - o1;
-            }
-        });
-
-        for (int i=0; i<k; i++) {
-            priorityQueue.add(nums[i]);
-        }
-
-        int j = 0;
-        for (int i=k; i<nums.length; i++) {
-
-            ans[j] = priorityQueue.peek();
-            priorityQueue.remove(nums[j]);
-            priorityQueue.add(nums[i]);
-            j++;
-        }
-
-        ans[j] = priorityQueue.peek();
-
-        return ans;
+    int[] result = new int[n - k + 1];
+    Deque<Integer> deque = new ArrayDeque<>();
+    for (int i = 0; i < n; i++) {
+      while (deque.size() > 0 && deque.peekFirst() <= i - k) {
+        deque.pollFirst();
+      }
+      while (deque.size() > 0 && nums[deque.peekLast()] < nums[i]) {
+        deque.pollLast();
+      }
+      deque.offerLast(i);
+      if (i >= k - 1) {
+        result[i -k + 1] = nums[deque.peekFirst()];
+      }
     }
+    return result;
+  }
 }
diff --git a/Medium/Diameter of N-ary Tree.java b/Medium/Diameter of N-ary Tree.java
new file mode 100644
index 00000000..96ac97a5
--- /dev/null
+++ b/Medium/Diameter of N-ary Tree.java	
@@ -0,0 +1,50 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    
+    public Node() {
+        children = new ArrayList<Node>();
+    }
+    
+    public Node(int _val) {
+        val = _val;
+        children = new ArrayList<Node>();
+    }
+    
+    public Node(int _val,ArrayList<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+  public int diameter(Node root) {
+    int[] max = {0};
+    helper(root, max);
+    return max[0];
+  }
+  
+  private int helper(Node root, int[] max) {
+    if (root == null) {
+      return 0;
+    }
+    int max1 = 0;
+    int max2 = 0;
+    for (Node child : root.children) {
+      int height = helper(child, max);
+      if (max1 < height) {
+        max2 = max1;
+        max1 = height;
+      }
+      else if (max2 < height) {
+        max2 = height;
+      }
+    }
+    max[0] = Math.max(max[0], max1 + max2);
+    return max1 + 1;
+  }
+}
diff --git a/Medium/Find Leaves of Binary Tree.java b/Medium/Find Leaves of Binary Tree.java
index af95d71a..1bb713cd 100644
--- a/Medium/Find Leaves of Binary Tree.java	
+++ b/Medium/Find Leaves of Binary Tree.java	
@@ -4,58 +4,35 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public List<List<Integer>> findLeaves(TreeNode root) {
-        List<List<Integer>> list = new ArrayList<>();
-        
-        while (root != null) {
-            List<Integer> leaves = getLeaves(root);
-            root = removeLeaves(root);
-            list.add(leaves);
-        }
-        
-        return list;
+  public List<List<Integer>> findLeaves(TreeNode root) {
+    List<List<Integer>> result = new ArrayList<>();
+    helper(result, root);
+    return result;
+  }
+  
+  private int helper(List<List<Integer>> result, TreeNode root) {
+    if (root == null) {
+      return -1;
     }
-    
-    private TreeNode removeLeaves(TreeNode root) {
-        if (root == null) {
-            return null;
-        }
-        
-        if (root.left == null && root.right == null) {
-            return null;
-        }
-        
-        root.left = removeLeaves(root.left);
-        root.right = removeLeaves(root.right);
-        
-        return root;
+    int left = helper(result, root.left);
+    int right = helper(result, root.right);
+    int maxDepth = Math.max(left, right) + 1;
+    if (maxDepth == result.size()) {
+      result.add(new ArrayList<>());
     }
-    
-    private List<Integer> getLeaves(TreeNode root) {
-        Queue<TreeNode> queue = new LinkedList<>();
-        queue.add(root);
-        List<Integer> list = new ArrayList<>();
-        
-        while (!queue.isEmpty()) {
-            TreeNode node = queue.remove();
-            if (node.left == null && node.right == null) {
-                list.add(node.val);
-            }
-            else {
-                if (node.left != null) {
-                    queue.add(node.left);
-                }
-                
-                if (node.right != null) {
-                    queue.add(node.right);
-                }
-            }
-        }
-        
-        return list;
-    } 
+    result.get(maxDepth).add(root.val);
+    // Cut the tree
+    root.left = root.right = null;
+    return maxDepth;
+  }
 }
diff --git a/Medium/Populating Next Right Pointers in Each Node II.java b/Medium/Populating Next Right Pointers in Each Node II.java
index d4cf5639..96dd48fc 100644
--- a/Medium/Populating Next Right Pointers in Each Node II.java	
+++ b/Medium/Populating Next Right Pointers in Each Node II.java	
@@ -7,8 +7,12 @@ class Node {
     public Node next;
 
     public Node() {}
+    
+    public Node(int _val) {
+        val = _val;
+    }
 
-    public Node(int _val,Node _left,Node _right,Node _next) {
+    public Node(int _val, Node _left, Node _right, Node _next) {
         val = _val;
         left = _left;
         right = _right;
@@ -16,33 +20,30 @@ public Node(int _val,Node _left,Node _right,Node _next) {
     }
 };
 */
+
 class Solution {
-    public Node connect(Node root) {
-        Queue<Node> queue = new LinkedList<>();
-        
-        queue.add(root);
-        queue.add(null);
-        
-        while (queue.peek() != null) {
-            int size = queue.size() - 1;
-            
-            while (size-- > 0) {
-                Node removed = queue.remove();
-                removed.next = queue.peek();
-                
-                if (removed.left != null) {
-                    queue.add(removed.left);
-                }
-                
-                if (removed.right != null) {
-                    queue.add(removed.right);
-                }
-            }
-            
-            queue.remove();
-            queue.add(null);
+  public Node connect(Node root) {
+    if (root == null) {
+      return null;
+    }
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(root);
+    queue.add(null);
+    while (!queue.isEmpty() && queue.peek() != null) {
+      int size = queue.size() - 1;
+      while (size-- > 0) {
+        Node removed = queue.remove();
+        removed.next = queue.peek();
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
         }
-        
-        return root;
+      }
+      queue.remove();
+      queue.add(null);
     }
+    return root;
+  }
 }

From 80d4867d8bc197fc8e169921cd917665c058bd4c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 24 Jul 2020 15:36:41 -0500
Subject: [PATCH 0244/2175] Added 1 solution & modified 3 solutions

---
 Medium/Combinations.java    | 45 ++++++++++++++++++-------------------
 Medium/Permutations II.java | 40 +++++++++++++++++++--------------
 Medium/Subsets II.java      | 25 +++++++++++++++++++++
 Medium/Subsets.java         | 28 ++++++++++++++---------
 4 files changed, 88 insertions(+), 50 deletions(-)
 create mode 100644 Medium/Subsets II.java

diff --git a/Medium/Combinations.java b/Medium/Combinations.java
index 23b1c7e6..f5d99e2b 100644
--- a/Medium/Combinations.java
+++ b/Medium/Combinations.java
@@ -1,27 +1,26 @@
 class Solution {
-    public List<List<Integer>> combine(int n, int k) {
-        List<Integer> temp = new ArrayList<>();
-        List<List<Integer>> ans = new ArrayList<>();
-        helper(n, 1, temp, ans, k);
-        
-        return ans;
+  public List<List<Integer>> combine(int n, int k) {
+    List<List<Integer>> ans = new ArrayList<>();
+    List<Integer> curr = new ArrayList<>();
+    helper(ans, curr, new boolean[n], k, 0);
+    return ans;
+  }
+  
+  private void helper(List<List<Integer>> ans, List<Integer> curr, boolean[] visited, int k, int idx) {
+    if (curr.size() == k) {
+      ans.add(new ArrayList<>(curr));
     }
-    
-    private void helper(int n, int start, List<Integer> temp, List<List<Integer>> ans, int len) {
-        if (temp.size() == len) {
-            ans.add(new ArrayList<>(temp));
-            return;
-        }
-        
-        for (int i=start; i<=n; i++) {
-            // Choose
-            temp.add(i);
-            
-            // Explore
-            helper(n, i+1, temp, ans, len);
-            
-            // Un-choose
-            temp.remove(temp.size() - 1);
+    else {
+      for (int i = idx; i < visited.length; i++) {
+        if (visited[i]) {
+          continue;
         }
+        curr.add(i + 1);
+        visited[i] = true;
+        helper(ans, curr, visited, k, i + 1);
+        curr.remove(curr.size() - 1);
+        visited[i] = false;
+      }
     }
-} 
+  }
+}
diff --git a/Medium/Permutations II.java b/Medium/Permutations II.java
index 1e74de1d..79757bf3 100644
--- a/Medium/Permutations II.java	
+++ b/Medium/Permutations II.java	
@@ -1,28 +1,34 @@
 class Solution {
   public List<List<Integer>> permuteUnique(int[] nums) {
-    Set<List<Integer>> ans = new HashSet <>();
-    Map <Integer, Integer> map = new HashMap <>();
-    for (int num : nums) {
-      map.put(num, map.getOrDefault(num, 0) + 1);
+    List<List<Integer>> ans = new ArrayList<>();
+    if (nums.length == 0) {
+      return ans;
     }
-    permuteHelper(nums, nums.length, ans, map, new ArrayList<>());
-    return new ArrayList <>(ans);
+    List<Integer> curr = new ArrayList<>();
+    Arrays.sort(nums);
+    helper(nums, ans, curr, new boolean[nums.length]);
+    return ans;
   }
-
-  private void permuteHelper(int[] nums, int length, Set<List<Integer>> ans, Map<Integer, Integer> used, ArrayList<Integer> curr) {
-    if (curr.size() == length) {
-      ans.add(new ArrayList <>(curr));
-      return;
+  
+  private void helper(int[] nums, List<List<Integer>> ans, List<Integer> curr, boolean[] used) {
+    if (curr.size() == nums.length) {
+      ans.add(new ArrayList<>(curr));
     }
-
-    for (int i = 0; i < length; i++) {
-      if (used.get(nums[i]) != 0) {
-        used.put(nums[i], used.get(nums[i]) - 1);
+    else {
+      for (int i = 0; i < nums.length; i++) {
+        if (used[i]) {
+          continue;
+        }
+        if (i > 0 && nums[i - 1] == nums[i] && !used[i - 1]) {
+          continue;
+        }
+        used[i] = true;
         curr.add(nums[i]);
-        permuteHelper(nums, length, ans, used, curr);
-        used.put(nums[i], used.get(nums[i]) + 1);
+        helper(nums, ans, curr, used);
         curr.remove(curr.size() - 1);
+        used[i] = false;
       }
     }
   }
 }
+
diff --git a/Medium/Subsets II.java b/Medium/Subsets II.java
new file mode 100644
index 00000000..72d290b7
--- /dev/null
+++ b/Medium/Subsets II.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public List<List<Integer>> subsetsWithDup(int[] nums) {
+    List<List<Integer>> ans = new ArrayList<>();
+    List<Integer> curr = new ArrayList<>();
+    int n = nums.length;
+    Arrays.sort(nums);
+    helper(nums, 0, n, ans, curr);
+    return new ArrayList<>(ans);
+  }
+  
+  private void helper(int[] nums, int idx, int n, List<List<Integer>> ans, List<Integer> curr) {
+    ans.add(new ArrayList<>(curr));
+    if (idx >= n) {
+      return;
+    }
+    for (int i = idx; i < n; i++) {
+      if (i > idx && nums[i] == nums[i - 1]) {
+        continue;
+      }
+      curr.add(nums[i]);
+      helper(nums, i + 1, n, ans, curr);
+      curr.remove(curr.size() - 1);
+    } 
+  }
+}
diff --git a/Medium/Subsets.java b/Medium/Subsets.java
index 753aa998..2bfb0c12 100644
--- a/Medium/Subsets.java
+++ b/Medium/Subsets.java
@@ -1,16 +1,24 @@
 class Solution {
   public List<List<Integer>> subsets(int[] nums) {
-    Set<List<Integer>> set = new HashSet<>();
-    helper(nums, 0, new ArrayList<>(), set);
-    return new ArrayList<>(set);
-  }
+    List<List<Integer>> list = new ArrayList<>();
+    List<Integer> curr = new ArrayList<>();
+    helper(list, curr, nums, 0, nums.length, new boolean[nums.length]);
+    return list;
+  }   
   
-  private void helper(int[] nums, int idx, List<Integer> temp, Set<List<Integer>> set) {
-    set.add(new ArrayList<>(temp));
-    for (int i = idx; i < nums.length; i++) {
-      temp.add(nums[i]);
-      helper(nums, i + 1, temp, set);
-      temp.remove(temp.size() - 1);
+  private void helper(List<List<Integer>> list, List<Integer> curr, int[] nums, int idx, int n, boolean[] seen) {
+    list.add(new ArrayList<>(curr));
+    if (idx >= n) {
+      return;
+    }
+    for (int i = idx; i < n; i++) {
+      if (!seen[i]) {
+        seen[i] = true;
+        curr.add(nums[i]);
+        helper(list, curr, nums, i + 1, n, seen);
+        seen[i] = false;
+        curr.remove(curr.size() - 1);
+      }
     }
   }
 }

From 4084797dc53176f630c0d9a0d21679eb77043b20 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 24 Jul 2020 18:40:41 -0500
Subject: [PATCH 0245/2175] Modified 2 solutions

---
 .../Analyze User Website Visit Pattern.java   | 96 ++++++++++---------
 Medium/Search Suggestions System.java         | 73 +++++++++-----
 2 files changed, 98 insertions(+), 71 deletions(-)

diff --git a/Medium/Analyze User Website Visit Pattern.java b/Medium/Analyze User Website Visit Pattern.java
index a15fbec5..def6a086 100644
--- a/Medium/Analyze User Website Visit Pattern.java	
+++ b/Medium/Analyze User Website Visit Pattern.java	
@@ -1,58 +1,62 @@
 class Solution {
   public List<String> mostVisitedPattern(String[] username, int[] timestamp, String[] website) {
-    List<List<String>> sessions = new ArrayList<>();
-    int n = timestamp.length;
-    // Form a session list -> user[i] at timestamp[i] visited website[i]
-    for (int i = 0; i < n; i++) {
-      sessions.add(new ArrayList<>());
-      sessions.get(i).add(username[i]);
-      sessions.get(i).add(String.valueOf(timestamp[i]));
-      sessions.get(i).add(website[i]);
+    Map<String, List<WebEntry>> map = new HashMap<>();
+    for (int i = 0; i < timestamp.length; i++) {
+      map.computeIfAbsent(username[i], k -> new ArrayList<>()).add(
+        new WebEntry(website[i], timestamp[i], username[i])
+      );
     }
-    // Sort by timestamp
-    sessions.sort((a, b) -> Integer.parseInt(a.get(1)) - Integer.parseInt(b.get(1)));
-    Map<String, List<String>> visited = new HashMap<>();
-    // Create a hashmap user -> list of websites visited
-    for (int i = 0; i < n; i++) {
-      visited.computeIfAbsent(sessions.get(i).get(0), k -> new ArrayList<>()).add(sessions.get(i).get(2));
-    }
-    Map<String, Integer> sequence = new HashMap<>();
-    int maxCount = 0;
-    String maxSeq = "";
-    for (String name : visited.keySet()) {
-      if (visited.get(name).size() >= 3) {
-        // Form all possible combination of websites visited of size 3
-        Set<String> subseqences = subseqence(visited.get(name));
-        for (String seq : subseqences){
-          sequence.put(seq, sequence.getOrDefault(seq, 0) + 1);
-          if(sequence.get(seq) > maxCount){
-            maxCount = sequence.get(seq);
-            maxSeq = seq;
-          }
-          else if (sequence.get(seq) == maxCount && seq.compareTo(maxSeq) < 0) {
-            maxSeq = seq;
+    Map<String, Set<String>> visitMap = new HashMap<>();
+    Set<String> threeSequenceSet = new HashSet<>(); 
+    for (String key : map.keySet()) {
+      List<WebEntry> webentries = map.get(key);
+      Collections.sort(webentries, new Comparator<WebEntry>(){
+        public int compare(WebEntry w1, WebEntry w2) {
+          return w1.timestamp - w2.timestamp;
+        }
+      });
+      for (int i = 0; i < webentries.size(); i++) {
+        for (int j = i + 1; j < webentries.size(); j++) {
+          for (int k = j + 1; k < webentries.size(); k++) {
+            String websiteKey = (
+              webentries.get(i).website + " " + 
+              webentries.get(j).website + " " + 
+              webentries.get(k).website
+            );
+            visitMap.computeIfAbsent(websiteKey, m -> new HashSet<>()).add(key);
+            threeSequenceSet.add(websiteKey);
           }
         }
       }
     }
-    String[] strs = maxSeq.split(",");
-    List<String> res = new ArrayList<>();
-    for (String s : strs) {
-      res.add(s);
-    }
-    return res;
-  }
-  
-  private Set<String> subseqence(List<String> list) {
-    Set<String> set = new HashSet<>();
-    int n = list.size();
-    for (int i = 0; i < n - 2; i++) {
-      for (int j = i + 1; j < n - 1; j++) {
-        for (int k = j + 1; k < n; k++) {
-          set.add(list.get(i) + "," + list.get(j) + "," + list.get(k));
+    List<String> threeSequenceList = new ArrayList<>(threeSequenceSet);
+    Collections.sort(threeSequenceList, new Comparator<String>(){
+      public int compare(String s1, String s2) {
+        int c = visitMap.get(s2).size() - visitMap.get(s1).size();
+        if (c != 0) {
+          return c;
         }
+        return s1.compareTo(s2);
       }
+    });
+    String[] ansArr = threeSequenceList.get(0).split("\\s+");
+    List<String> ans = new ArrayList<>();
+    for (int i = 0; i < ansArr.length; i++) {
+      ans.add(ansArr[i]);
     }
-    return set;
+    return ans;
+  }
+}
+
+
+class WebEntry {
+  String website;
+  int timestamp;
+  String username;
+  
+  public WebEntry(String website, int timestamp, String username) {
+    this.website = website;
+    this.timestamp = timestamp;
+    this.username = username;
   }
 }
diff --git a/Medium/Search Suggestions System.java b/Medium/Search Suggestions System.java
index 618e4fe5..465bde7f 100644
--- a/Medium/Search Suggestions System.java	
+++ b/Medium/Search Suggestions System.java	
@@ -1,36 +1,59 @@
 class Solution {
   public List<List<String>> suggestedProducts(String[] products, String searchWord) {
-    List<List<String>> ans = new ArrayList<>();
-    List<String> prev = new ArrayList<>();
-    for (int i = 0; i < searchWord.length(); i++) {
-      List<String> curr = new ArrayList<>();
-      List<String> temp = new ArrayList<>();
-      PriorityQueue<String> pq = new PriorityQueue<>(Comparator.reverseOrder());
-      if (i == 0) {
-        helper(Arrays.asList(products), searchWord, i, curr, pq);
+    Node root = new Node('-');
+    for (String product : products) {
+      addProduct(product, root);
+    }
+    List<List<String>> list = new ArrayList<>();
+    Node curr = root;
+    boolean notFound = false;
+    for (char c : searchWord.toCharArray()) {
+      if (notFound) {
+        list.add(new ArrayList<>());
       }
       else {
-        helper(prev, searchWord, i, curr, pq);
-      }
-      while (!pq.isEmpty()) {
-        temp.add(pq.poll());
+        if (!curr.children.containsKey(c)) {
+          notFound = true;
+          list.add(new ArrayList<>());
+          continue;
+        }
+        curr = curr.children.get(c);
+        List<String> temp = new ArrayList<>();
+        PriorityQueue<String> words = new PriorityQueue<>(curr.possibleWords);
+        for (int i = 0; i < 3 && !words.isEmpty(); i++) {
+          temp.add(words.poll());
+        }
+        Collections.reverse(temp);
+        list.add(temp);
       }
-      Collections.sort(temp);
-      ans.add(temp);
-      prev = curr;
     }
-    return ans;
+    return list;
   }
-
-  private void helper(List<String> products, String searchWord, int i, List<String> curr, PriorityQueue<String> pq) {
-    for (String word : products) {
-      if (i < word.length() && word.charAt(i) == searchWord.charAt(i)) {
-        curr.add(word);
-        pq.add(word);
-        if (pq.size() > 3) {
-          pq.poll();
-        }
+  
+  private void addProduct(String product, Node root) {
+    Node curr = root;
+    for (int i = 0; i < product.length(); i++) {
+      if (!curr.children.containsKey(product.charAt(i))) {
+        curr.children.put(product.charAt(i), new Node(product.charAt(i)));
+      }
+      curr = curr.children.get(product.charAt(i));
+      curr.possibleWords.add(product);
+      if (curr.possibleWords.size() > 3) {
+        curr.possibleWords.poll();
       }
     }
   }
 }
+
+
+class Node {
+  char c;
+  Map<Character, Node> children;
+  PriorityQueue<String> possibleWords;
+  
+  public Node(char c) {
+    this.c = c;
+    children = new HashMap<>();
+    possibleWords = new PriorityQueue<>(Comparator.reverseOrder());
+  }
+}

From a8a390d7cd4ede8e9db91931e6501bc7553a7c06 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 25 Jul 2020 14:32:06 -0500
Subject: [PATCH 0246/2175] Added 1 solution & modified 1 solution

---
 ...ount Odd Numbers in an Interval Range.java |  5 +++
 ...nd Minimum in Rotated Sorted Array II.java | 40 ++++++++-----------
 2 files changed, 21 insertions(+), 24 deletions(-)
 create mode 100644 Easy/Count Odd Numbers in an Interval Range.java

diff --git a/Easy/Count Odd Numbers in an Interval Range.java b/Easy/Count Odd Numbers in an Interval Range.java
new file mode 100644
index 00000000..68fe1652
--- /dev/null
+++ b/Easy/Count Odd Numbers in an Interval Range.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public int countOdds(int low, int high) {
+    return (high + 1) / 2 - low / 2;
+  }
+}
diff --git a/Hard/Find Minimum in Rotated Sorted Array II.java b/Hard/Find Minimum in Rotated Sorted Array II.java
index 3f383eef..524fa9a3 100644
--- a/Hard/Find Minimum in Rotated Sorted Array II.java	
+++ b/Hard/Find Minimum in Rotated Sorted Array II.java	
@@ -1,27 +1,19 @@
 class Solution {
-    public int findMin(int[] nums) {
-        int start = 0;
-        int end = nums.length-1;
-        int minVal = Integer.MAX_VALUE;
-
-        while (start <= end) {
-            int mid = (start + end)/2;
-            if (((mid > 0 ? nums[mid] < nums[mid-1] : true) && (mid < nums.length-1 ? nums[mid] < nums[mid+1] : true))) {
-                return nums[mid];
-            }
-            else if (nums[mid] < nums[end]) {
-                end = mid;
-            }
-            else if (nums[mid] > nums[end]){
-                start = mid+1;
-            }
-            else {
-                end--;
-            }
-
-            minVal = Math.min(nums[mid], minVal);
-        }
-
-        return minVal;
+  public int findMin(int[] nums) {
+    int start = 0;
+    int end = nums.length - 1;
+    while (start <= end) {
+      int mid = start + (end - start) / 2;
+      if (nums[mid] < nums[end]) {
+        end = mid;
+      }
+      else if (nums[mid] > nums[end]) {
+        start = mid + 1;
+      }
+      else {
+        end--;
+      }
     }
+    return nums[start];
+  }
 }

From 41d48359f9b4486021bc710f24cd8c6bec1e5a89 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Jul 2020 15:21:47 -0500
Subject: [PATCH 0247/2175] Added 1 solution & modified 4 solutions

---
 Easy/Bold Words in String.java            | 63 +++++++++--------------
 Easy/Moving Average from Data Stream.java | 36 ++++++-------
 Easy/Shuffle String.java                  |  9 ++++
 Medium/Add Bold Tag in String.java        | 62 +++++++++-------------
 Medium/Missing Ranges.java                | 48 ++++++++---------
 5 files changed, 97 insertions(+), 121 deletions(-)
 create mode 100644 Easy/Shuffle String.java

diff --git a/Easy/Bold Words in String.java b/Easy/Bold Words in String.java
index d17849db..16d3e6d3 100644
--- a/Easy/Bold Words in String.java	
+++ b/Easy/Bold Words in String.java	
@@ -1,43 +1,30 @@
 class Solution {
-    public String boldWords(String[] words, String S) {
-        if (S.length() == 0 || words.length == 0) {
-            return S;
+  public String boldWords(String[] words, String S) {
+    int N = S.length();
+    boolean[] mask = new boolean[N];
+    for (int i = 0; i < N; ++i) {
+      for (String word: words) search: {
+        for (int k = 0; k < word.length(); ++k) {
+          if (k + i >= S.length() || S.charAt(k + i) != word.charAt(k)) {
+            break search;
+          }
         }
-
-        int l = S.length();
-        int[] match = new int[l];
-
-        for (String word : words) {
-            int idx = 0;
-            while (idx < l) {
-                int startIdx = S.indexOf(word, idx);
-                if (startIdx != -1) {
-                    for (int i = startIdx; i < startIdx + word.length(); i++) {
-                        match[i] = 1;
-                    }
-
-                    idx = startIdx + 1;
-                }
-                else {
-                    break;
-                }
-            }
+        for (int j = i; j < i + word.length(); ++j) {
+          mask[j] = true;
         }
-
-        String startTag = "<b>";
-        String endTag = "</b>";
-
-        StringBuilder sb = new StringBuilder();
-        for (int i=0; i<l; i++) {
-            if ((i == 0 || match[i-1] == 0) && match[i] == 1) {
-                sb.append(startTag);
-            }
-            sb.append(S.charAt(i));
-            if ((i == l-1 || match[i+1] == 0) && match[i] == 1) {
-                sb.append(endTag);
-            }
-        }
-
-        return sb.toString();
+      }
+    }
+    StringBuilder ans = new StringBuilder();
+    int anchor = 0;
+    for (int i = 0; i < N; ++i) {
+      if (mask[i] && (i == 0 || !mask[i - 1])) {
+        ans.append("<b>");
+      }
+      ans.append(S.charAt(i));
+      if (mask[i] && (i == N - 1 || !mask[i + 1])) {
+        ans.append("</b>");
+      }
     }
+    return ans.toString();
+  }
 }
diff --git a/Easy/Moving Average from Data Stream.java b/Easy/Moving Average from Data Stream.java
index 04933639..1c218cfb 100644
--- a/Easy/Moving Average from Data Stream.java	
+++ b/Easy/Moving Average from Data Stream.java	
@@ -1,25 +1,23 @@
 class MovingAverage {
 
-    /** Initialize your data structure here. */
-    Queue<Integer> queue;
-    int size;
-    double total;
-    public MovingAverage(int size) {
-        queue = new LinkedList<>();
-        this.size = size;
-        this.total = 0.0;
-    }
-    
-    public double next(int val) {
-        queue.add(val);
-        this.total += val;
-        
-        if (queue.size() > this.size) {
-            total -= queue.remove();
-        }
-        
-        return total / queue.size();
+  /** Initialize your data structure here. */
+  Queue<Integer> queue;
+  int size;
+  double sum;
+  public MovingAverage(int size) {
+    sum = 0;
+    this.size = size;
+    queue = new LinkedList<>();
+  }
+
+  public double next(int val) {
+    queue.add(val);
+    sum += val;
+    if (queue.size() > size) {
+      sum -= queue.remove();
     }
+    return sum / queue.size();
+  }
 }
 
 /**
diff --git a/Easy/Shuffle String.java b/Easy/Shuffle String.java
new file mode 100644
index 00000000..5b82086f
--- /dev/null
+++ b/Easy/Shuffle String.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public String restoreString(String s, int[] indices) {
+    char[] letters = new char[s.length()];
+    for (int i = 0; i < indices.length; i++) {
+      letters[indices[i]] = s.charAt(i);
+    }
+    return String.valueOf(letters);
+  }
+}
diff --git a/Medium/Add Bold Tag in String.java b/Medium/Add Bold Tag in String.java
index 99e3c57f..bd262a02 100644
--- a/Medium/Add Bold Tag in String.java	
+++ b/Medium/Add Bold Tag in String.java	
@@ -1,42 +1,30 @@
 class Solution {
-    public String addBoldTag(String s, String[] dict) {
-        boolean[] bold = new boolean[s.length()];
-        int end = 0;
-
-        for (int i=0; i<s.length(); i++) {
-            boolean found = false;
-            for (String word : dict) {
-                if (s.startsWith(word, i)) {
-                    found = true;
-                    end = Math.max(end, i + word.length());
-                }
-
-                int j = i;
-                if (found) {
-                    while (j < end) {
-                        bold[j] = found;
-                        j++;
-                    }
-                }
-            }
+  public String addBoldTag(String S, String[] dict) {
+    int N = S.length();
+    boolean[] mask = new boolean[N];
+    for (int i = 0; i < N; ++i) {
+      for (String word: dict) search: {
+        for (int k = 0; k < word.length(); ++k) {
+          if (k + i >= S.length() || S.charAt(k + i) != word.charAt(k)) {
+            break search;
+          }
         }
-
-
-        StringBuilder sb = new StringBuilder();
-        for (int i=0; i<s.length(); i++) {
-            if (!bold[i]) {
-                sb.append(s.charAt(i));
-                continue;
-            }
-
-            int j = i;
-            while (j < s.length() && bold[j]) {
-                j++;
-            }
-            sb.append("<b>").append(s.substring(i, j) + "</b>");
-            i = j-1;
+        for (int j = i; j < i + word.length(); ++j) {
+          mask[j] = true;
         }
-
-        return sb.toString();
+      }
     }
+    StringBuilder ans = new StringBuilder();
+    int anchor = 0;
+    for (int i = 0; i < N; ++i) {
+      if (mask[i] && (i == 0 || !mask[i - 1])) {
+        ans.append("<b>");
+      }
+      ans.append(S.charAt(i));
+      if (mask[i] && (i == N - 1 || !mask[i + 1])) {
+        ans.append("</b>");
+      }
+    }
+    return ans.toString();
+  }
 }
diff --git a/Medium/Missing Ranges.java b/Medium/Missing Ranges.java
index bb57ffd0..66d05e39 100644
--- a/Medium/Missing Ranges.java	
+++ b/Medium/Missing Ranges.java	
@@ -1,31 +1,25 @@
 class Solution {
-    public List<String> findMissingRanges(int[] nums, int lower, int upper) {
-        List<String> list = new ArrayList<>();
-        long next = lower;
-        
-        for (int i = 0; i < nums.length; i++) {
-            if (nums[i] < next) {
-                continue;
-            }
-            
-            if (nums[i] == next) {
-                next++;
-                continue;
-            }
-            
-            list.add(getRange(next, ((long) nums[i]) - 1));
-            
-            next = ((long) nums[i]) + 1;
-        }
-        
-        if (next <= upper) {
-            list.add(getRange(next, (long) upper));
-        }
-        
-        return list;
+  public List<String> findMissingRanges(int[] nums, int lower, int upper) {
+    List<String> ranges = new ArrayList<>();
+    long currLower = (long) lower;
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] < currLower) {
+        continue;
+      }
+      if (nums[i] == currLower) {
+        currLower++;
+        continue;
+      }
+      ranges.add(getRange(currLower, ((long) nums[i] - 1)));
+      currLower = ((long) nums[i]) + 1;
     }
-    
-    private String getRange(long down, long up) {
-        return up == down ? String.valueOf(up) : String.format("%d->%d", down, up);
+    if (currLower <= upper) {
+      ranges.add(getRange(currLower, (long) upper));
     }
+    return ranges;
+  }
+  
+  private String getRange(long down, long up) {
+    return down == up ? String.valueOf(up) : down + "->" + up;
+  }
 }

From 077affbb0a8a9125bfd7e89f504d6a66f03b7ef1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 27 Jul 2020 10:30:48 -0500
Subject: [PATCH 0248/2175] Added 1 solution & modified 5 solutions

---
 Easy/Factorial Trailing Zeroes.java           | 15 +++---
 Easy/Longest Common Prefix.java               | 37 +++++++++-----
 ...est Continuous Increasing Subsequence.java | 33 +++++++------
 Hard/Insert Interval.java                     | 49 +++++++++++++++++++
 Medium/Container With Most Water.java         | 37 ++++++--------
 Medium/Rotate Image.java                      | 27 +++++-----
 6 files changed, 126 insertions(+), 72 deletions(-)
 create mode 100644 Hard/Insert Interval.java

diff --git a/Easy/Factorial Trailing Zeroes.java b/Easy/Factorial Trailing Zeroes.java
index 71b0f24d..74d5b2b0 100644
--- a/Easy/Factorial Trailing Zeroes.java	
+++ b/Easy/Factorial Trailing Zeroes.java	
@@ -1,11 +1,10 @@
 class Solution {
-    public int trailingZeroes(int n) {
-        int count = 0;
-        while (n > 4) {
-            count += n/5;
-            n = n/5;
-        }
-        
-        return count;
+  public int trailingZeroes(int n) {
+    int count = 0;
+    while (n > 4) {
+      count += n / 5;
+      n = n / 5;
     }
+    return count;
+  }
 }
diff --git a/Easy/Longest Common Prefix.java b/Easy/Longest Common Prefix.java
index ed905d22..49a0dc92 100644
--- a/Easy/Longest Common Prefix.java	
+++ b/Easy/Longest Common Prefix.java	
@@ -1,15 +1,30 @@
 class Solution {
-    public String longestCommonPrefix(String[] strs) {
-        if (strs == null || strs.length == 0) return "";
-        
-        String ans = strs[0];
-        
-        for (int i=1;i<strs.length;i++) {
-            while(strs[i].indexOf(ans) != 0) {
-                ans = ans.substring(0,ans.length()-1);
-            }
+  public String longestCommonPrefix(String[] strs) {
+    if (strs.length == 0) {
+      return "";
+    }
+    int minLength = Integer.MAX_VALUE;
+    int idx = -1;
+    for (int i = 0; i < strs.length; i++) {
+      if (strs[i].length() < minLength) {
+        minLength = strs[i].length();
+        idx = i;
+      }
+    }
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < strs[idx].length(); i++) {
+      boolean flag = true;
+      for (String str : strs) {
+        if (str.charAt(i) != strs[idx].charAt(i)) {
+          flag = false;
+          break;
         }
-        
-        return ans;
+      }
+      if (!flag) {
+        break;
+      }
+      sb.append(strs[idx].charAt(i));
     }
+    return sb.toString();
+  }
 }
diff --git a/Easy/Longest Continuous Increasing Subsequence.java b/Easy/Longest Continuous Increasing Subsequence.java
index a70df9d9..77d31e56 100644
--- a/Easy/Longest Continuous Increasing Subsequence.java	
+++ b/Easy/Longest Continuous Increasing Subsequence.java	
@@ -1,19 +1,20 @@
 class Solution {
-    public int findLengthOfLCIS(int[] nums) {
-        if (nums.length == 0) return 0;
-        if (nums.length == 1) return 1;
-        
-        int c = 1;
-        int maxL = 1;
-        for (int i=1;i<nums.length;i++) {
-            if (nums[i-1] < nums[i]) {
-                c++;
-            }
-            else {
-                maxL = Math.max(c,maxL);
-                c = 1;
-            }
-        }
-        return Math.max(c,maxL);
+  public int findLengthOfLCIS(int[] nums) {
+    if (nums.length == 0) {
+      return 0;
     }
+    int maxLength = 1;
+    int currCount = 1;
+    int n = nums.length;
+    for (int i = 1; i < n; i++) {
+      if (nums[i] > nums[i - 1]) {
+        currCount++;
+      }
+      else {
+        maxLength = Math.max(maxLength, currCount);
+        currCount = 1;
+      }
+    }
+    return Math.max(maxLength, currCount);
+  }
 }
diff --git a/Hard/Insert Interval.java b/Hard/Insert Interval.java
new file mode 100644
index 00000000..a4b6f9cc
--- /dev/null
+++ b/Hard/Insert Interval.java	
@@ -0,0 +1,49 @@
+class Solution {
+  public int[][] insert(int[][] intervals, int[] newInterval) {
+    List<int[]> list = new ArrayList<>();
+    boolean merged = false;
+    int idx = 0;
+    int n = intervals.length;
+    while (idx < n) {
+      if (merged) {
+        list.add(intervals[idx++]);
+        continue;
+      }
+      if (isOverlap(intervals[idx], newInterval)) {
+        int start = Math.min(intervals[idx][0], newInterval[0]);
+        int currEnd = Math.max(intervals[idx][1], newInterval[1]);
+        idx++;
+        while (idx < n && intervals[idx][0] <= currEnd) {
+          currEnd = Math.max(currEnd, intervals[idx][1]);
+          idx++;
+        }
+        list.add(new int[]{start, currEnd});
+        merged = true;
+      }
+      else if (intervals[idx][0] > newInterval[1]) {
+        list.add(newInterval);
+        list.add(intervals[idx++]);
+        merged = true;
+      }
+      else {
+        list.add(intervals[idx++]);
+      }
+    }
+    if (!merged) {
+      list.add(newInterval);
+    }
+    int[][] ans = new int[list.size()][2];
+    for (int i = 0; i < list.size(); i++) {
+      ans[i] = list.get(i);
+    }
+    return ans;
+  }
+  
+  private boolean isOverlap(int[] i1, int[] i2) {
+    return (
+      (i2[0] <= i1[1] && i2[0] >= i1[0]) ||
+      (i2[1] >= i1[0] && i2[0] <= i1[0]) ||
+      (i2[0] >= i1[0] && i2[1] <= i1[1])
+    );
+  }
+}
diff --git a/Medium/Container With Most Water.java b/Medium/Container With Most Water.java
index 3bf46cf0..fbdacebf 100644
--- a/Medium/Container With Most Water.java	
+++ b/Medium/Container With Most Water.java	
@@ -1,24 +1,19 @@
 class Solution {
-    public int maxArea(int[] height) {
-        int start = 0;
-        int end = height.length - 1;
-        int mul = end;
-        int res = Integer.MIN_VALUE;
-
-        while (end - start >= 1) {
-            int temp = mul * Math.min(height[start], height[end]);
-            res = Math.max(res, temp);
-
-            if (height[start] < height[end]) {
-                start++;
-            }
-            else {
-                end--;
-            }
-
-            mul--;
-        }
-
-        return res;
+  public int maxArea(int[] height) {
+    int start = 0;
+    int end = height.length - 1;
+    int maxArea = 0;
+    while (start < end) {
+      int minHeight = Math.min(height[start], height[end]);
+      int dist = end - start;
+      maxArea = Math.max(maxArea, minHeight * dist);
+      if (height[start] > height[end]) {
+        end--;
+      }
+      else {
+        start++;
+      }
     }
+    return maxArea;
+  }
 }
diff --git a/Medium/Rotate Image.java b/Medium/Rotate Image.java
index f90d06ac..ad3e759d 100644
--- a/Medium/Rotate Image.java	
+++ b/Medium/Rotate Image.java	
@@ -1,19 +1,14 @@
 class Solution {
-    public void rotate(int[][] matrix) {
-        for (int i=0;i<matrix.length;i++) {
-            for (int j=i;j<matrix[0].length;j++) {
-                int temp = matrix[i][j];
-                matrix[i][j] = matrix[j][i];
-                matrix[j][i] = temp;
-            }
-        }
-        
-        for (int i=0;i<matrix.length;i++) {
-            for (int j=0;j<matrix.length/2;j++) {
-                int temp = matrix[i][j];
-                matrix[i][j] = matrix[i][matrix.length-1-j];
-                matrix[i][matrix.length-1-j] = temp;
-            }
-        }
+  public void rotate(int[][] matrix) {
+    int n = matrix.length;
+    for (int i = 0; i < (n + 1) / 2; i++) {
+      for (int j = 0; j < n / 2; j++) {
+        int temp = matrix[n - 1 - j][i];
+        matrix[n - 1 - j][i] = matrix[n - 1 - i][n - j - 1];
+        matrix[n - 1 - i][n - j - 1] = matrix[j][n - 1 - i];
+        matrix[j][n - 1 - i] = matrix[i][j];
+        matrix[i][j] = temp;
+      }
     }
+  }
 }

From a97feab9bcf0992346db39e56ef018bae477fe64 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 28 Jul 2020 10:35:51 -0500
Subject: [PATCH 0249/2175] Added 1 solution & modified 4 solutions

---
 Easy/Linked List Cycle.java                   | 21 +++----
 Easy/Minimum Index Sum of Two Lists.java      | 54 ++++++++----------
 ...um Number of Arrows to Burst Balloons.java | 49 ++++++++---------
 ...inimum Score Triangulation of Polygon.java | 16 ++++++
 Medium/Task Scheduler.java                    | 55 +++++--------------
 5 files changed, 85 insertions(+), 110 deletions(-)
 create mode 100644 Medium/Minimum Score Triangulation of Polygon.java

diff --git a/Easy/Linked List Cycle.java b/Easy/Linked List Cycle.java
index 8de7f13c..6c55e388 100644
--- a/Easy/Linked List Cycle.java	
+++ b/Easy/Linked List Cycle.java	
@@ -10,15 +10,16 @@
  * }
  */
 public class Solution {
-    public boolean hasCycle(ListNode head) {
-        ListNode fast = head;
-        ListNode slow = head;
-        
-        while (fast != null && fast.next != null) {
-            slow = slow.next;
-            fast = fast.next.next;
-            if (slow == fast) return true;
-        }
-        return false;
+  public boolean hasCycle(ListNode head) {
+    ListNode slow = head;
+    ListNode fast = head;
+    while (fast != null && fast.next != null) {
+      slow = slow.next;
+      fast = fast.next.next;
+      if (slow == fast) {
+        return true;
+      }
     }
+    return false;
+  }
 }
diff --git a/Easy/Minimum Index Sum of Two Lists.java b/Easy/Minimum Index Sum of Two Lists.java
index 48961a20..1a11f2d3 100644
--- a/Easy/Minimum Index Sum of Two Lists.java	
+++ b/Easy/Minimum Index Sum of Two Lists.java	
@@ -1,38 +1,28 @@
 class Solution {
-    public String[] findRestaurant(String[] list1, String[] list2) {
-        Map<String, Integer> map1 = createMap(list1);
-        Map<String, Integer> map2 = createMap(list2);
-        int minIndexSum = Integer.MAX_VALUE;
-        int count = 0;
-        for (String key : map1.keySet()) {
-            if (map2.containsKey(key)) {
-                int idxSum = map1.get(key) + map2.get(key);
-                if (idxSum < minIndexSum) {
-                    minIndexSum = idxSum;
-                    count = 1;
-                }
-                else if (idxSum == minIndexSum){
-                    count++;
-                }
-            }
+  public String[] findRestaurant(String[] list1, String[] list2) {
+    Map<String, Integer> map = new HashMap<>();
+    for (int i = 0; i < list1.length; i++) {
+      map.put(list1[i], i);
+    }
+    List<String> list = new ArrayList<>();
+    int minIndexSum = Integer.MAX_VALUE;
+    for (int i = 0; i < list2.length; i++) {
+      if (map.containsKey(list2[i])) {
+        int indexSum = map.get(list2[i]) + i;
+        if (indexSum < minIndexSum) {
+          minIndexSum = indexSum;
+          list = new ArrayList<>();
+          list.add(list2[i]);
         }
-        String[] ans = new String[count];
-        int idx = 0;
-        for (String key : map1.keySet()) {
-            if (map2.containsKey(key)) {
-                if (map1.get(key) + map2.get(key) == minIndexSum) {
-                    ans[idx++] = key;
-                }
-            }
+        else if (indexSum == minIndexSum) {
+          list.add(list2[i]);
         }
-        return ans;
+      }
     }
-
-    private Map<String, Integer> createMap(String[] list) {
-        Map<String, Integer> map = new HashMap<>();
-        for (int i = 0; i < list.length; i++) {
-            map.put(list[i], i);
-        }
-        return map;
+    String[] ans = new String[list.size()];
+    for (int i = 0; i < list.size(); i++) {
+      ans[i] = list.get(i);
     }
+    return ans;
+  }
 }
diff --git a/Medium/Minimum Number of Arrows to Burst Balloons.java b/Medium/Minimum Number of Arrows to Burst Balloons.java
index 48740783..b801e00b 100644
--- a/Medium/Minimum Number of Arrows to Burst Balloons.java	
+++ b/Medium/Minimum Number of Arrows to Burst Balloons.java	
@@ -1,30 +1,27 @@
 class Solution {
-    public static int findMinArrowShots(int[][] points) {
-        if (points.length == 0) {
-            return 0;
-        }
-        
-        Arrays.sort(points, new Comparator<int[]>() {
-            @Override
-            public int compare(int[] o1, int[] o2) {
-                return o1[0] - o2[0];
-            }
-        });
-
-        int[] start = points[0];
-        int count = 1;
-
-        for (int i=1; i<points.length; i++) {
-            if (points[i][0] <= start[1]) {
-                start[1] = Math.min(start[1], points[i][1]);
-                continue;
-            }
-            else {
-                count++;
-                start = points[i];
-            }
+  public int findMinArrowShots(int[][] points) {
+    if (points.length == 0) {
+      return 0;
+    }
+    Arrays.sort(points, new Comparator<int[]>(){
+      public int compare(int[] p1, int[] p2) {
+        int c = p1[0] - p2[0];
+        if (c != 0) {
+          return c;
         }
-
-        return count;
+        return p1[1] - p2[1];
+      }
+    });
+    int end = points[0][1];
+    int count = 1;
+    for (int i = 1; i < points.length; i++) {
+      if (points[i][0] <= end) {
+        end = Math.min(end, points[i][1]);
+        continue;
+      }
+      count++;
+      end = points[i][1];
     }
+    return count;
+  }
 }
diff --git a/Medium/Minimum Score Triangulation of Polygon.java b/Medium/Minimum Score Triangulation of Polygon.java
new file mode 100644
index 00000000..e94c16c2
--- /dev/null
+++ b/Medium/Minimum Score Triangulation of Polygon.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int minScoreTriangulation(int[] A) {
+    int n = A.length;
+    int[][] dp = new int[n][n];
+    for (int d = 2; d < n; ++d) {
+      for (int i = 0; i + d < n; ++i) {
+        int j = i + d;
+        dp[i][j] = Integer.MAX_VALUE;
+        for (int k = i + 1; k < j; ++k) {
+          dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k][j] + A[i] * A[j] * A[k]);
+        }
+      }
+    }
+    return dp[0][n - 1];
+  }
+}
diff --git a/Medium/Task Scheduler.java b/Medium/Task Scheduler.java
index e8843bf8..5d535437 100644
--- a/Medium/Task Scheduler.java	
+++ b/Medium/Task Scheduler.java	
@@ -1,45 +1,16 @@
 class Solution {
-    public int leastInterval(char[] tasks, int n) {
-        Map<Character, Integer> map = new HashMap<>();
-        for (char task : tasks) {
-            map.put(task, map.getOrDefault(task, 0) + 1);
-        }
-
-        PriorityQueue<Character> pq = new PriorityQueue<>((o1, o2) -> {
-            int c = map.get(o2).compareTo(map.get(o1));
-            if (c != 0) {
-                return c;
-            }
-
-            return o1 - o2;
-        });
-        pq.addAll(map.keySet());
-
-        int count = 0;
-        while (!pq.isEmpty()) {
-            int jump = n + 1;
-            List<Character> temp = new ArrayList<>();
-            while (jump > 0 && !pq.isEmpty()) {
-                Character polled = pq.poll();
-                map.put(polled, map.get(polled) - 1);
-                temp.add(polled);
-                jump--;
-                count++;
-            }
-
-            for (Character executedTask : temp) {
-                if (map.get(executedTask) > 0) {
-                    pq.add(executedTask);
-                }
-            }
-
-            if (pq.isEmpty()) {
-                break;
-            }
-
-            count += jump;
-        }
-
-        return count;
+  public int leastInterval(char[] tasks, int n) {
+    int[] counter = new int[26];
+    for (char task : tasks) {
+      counter[task - 'A']++;
     }
+    Arrays.sort(counter);
+    int maxFrequency = counter[25];
+    int idleTime = (maxFrequency - 1) * n;
+    for (int i = counter.length - 2; i >= 0 && idleTime > 0; i--) {
+      idleTime -= Math.min(maxFrequency - 1, counter[i]);
+    }
+    idleTime = Math.max(0, idleTime);
+    return idleTime + tasks.length;
+  }
 }

From e3aa7feb31e2c0f51c68a7563fc302edad1e183e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 29 Jul 2020 07:37:44 -0500
Subject: [PATCH 0250/2175] Added 2 solutions

---
 ...e to Buy and Sell Stock with Cooldown.java | 39 +++++++++++++++++++
 Medium/Guess Number Higher or Lower II.java   | 16 ++++++++
 2 files changed, 55 insertions(+)
 create mode 100644 Medium/Best Time to Buy and Sell Stock with Cooldown.java
 create mode 100644 Medium/Guess Number Higher or Lower II.java

diff --git a/Medium/Best Time to Buy and Sell Stock with Cooldown.java b/Medium/Best Time to Buy and Sell Stock with Cooldown.java
new file mode 100644
index 00000000..bb6693c2
--- /dev/null
+++ b/Medium/Best Time to Buy and Sell Stock with Cooldown.java	
@@ -0,0 +1,39 @@
+class Solution {
+  int[] prices;
+  Integer[] buyCache;
+  Integer[] sellCache;
+  public int maxProfit(int[] prices) {
+    this.prices = prices;
+    this.buyCache = new Integer[prices.length];
+    this.sellCache = new Integer[prices.length];
+    return buy(0);
+  }
+  
+  private int buy(int idx) {
+    if (idx >= prices.length) {
+      return 0;
+    }
+    if (buyCache[idx] != null) {
+      return buyCache[idx];
+    }
+    int cost = -prices[idx];
+    int bestProfitBuying = sell(idx + 1) + cost;
+    int bestProfitNotBuying = buy(idx + 1);
+    buyCache[idx] = Math.max(bestProfitBuying, bestProfitNotBuying);
+    return buyCache[idx];
+  }
+  
+  private int sell(int idx) {
+    if (idx == prices.length) {
+      return 0;
+    }
+    if (sellCache[idx] != null) {
+      return sellCache[idx];
+    }
+    int price = prices[idx];
+    int bestProftSelling = buy(idx + 2) + price;
+    int bestProfitNotSelling = sell(idx + 1);
+    sellCache[idx] = Math.max(bestProftSelling, bestProfitNotSelling);
+    return sellCache[idx];
+  }
+}
diff --git a/Medium/Guess Number Higher or Lower II.java b/Medium/Guess Number Higher or Lower II.java
new file mode 100644
index 00000000..1cd79784
--- /dev/null
+++ b/Medium/Guess Number Higher or Lower II.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int getMoneyAmount(int n) {
+    int[][] dp = new int[n + 1][n + 1];
+    for (int i = 2; i <= n; i++) {
+      for (int j = 1; j <= n -i + 1; j++) {
+        int minres = Integer.MAX_VALUE;
+        for (int k = j; k < j + i - 1; k++) {
+          int res = k + Math.max(dp[j][k - 1], dp[k + 1][j + i - 1]);
+          minres = Math.min(minres, res);
+        }
+        dp[j][j + i - 1] = minres;
+      }
+    }
+    return dp[1][n];
+  }
+}

From ae5e9c02ac5e449a5d7e59888604f65c39a7a23c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 30 Jul 2020 10:23:29 -0500
Subject: [PATCH 0251/2175] Added 1 solution & modified 2 solutions

---
 Medium/Find and Replace in String.java        | 48 +++++++++++--------
 .../Find the Index of the Large Integer.java  | 38 +++++++++++++++
 Medium/Shortest Way to Form String.java       | 44 +++++++++--------
 3 files changed, 91 insertions(+), 39 deletions(-)
 create mode 100644 Medium/Find the Index of the Large Integer.java

diff --git a/Medium/Find and Replace in String.java b/Medium/Find and Replace in String.java
index 2706b81e..9c5c6810 100644
--- a/Medium/Find and Replace in String.java	
+++ b/Medium/Find and Replace in String.java	
@@ -1,24 +1,34 @@
 class Solution {
-    public String findReplaceString(String S, int[] indexes, String[] sources, String[] targets) {
-        Map<Integer, String> sourceMap = new HashMap<>();
-        Map<Integer, String> targetMap = new HashMap<>();
-        
-        for (int i=0; i<indexes.length; i++) {
-            sourceMap.put(indexes[i], sources[i]);
-            targetMap.put(indexes[i], targets[i]);
+  public String findReplaceString(String S, int[] indexes, String[] sources, String[] targets) {
+    Map<Integer, String[]> map = new HashMap<>();
+    for (int i = 0; i < indexes.length; i++) {
+      map.put(indexes[i], new String[]{sources[i], targets[i]});
+    }
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < S.length(); i++) {
+      if (map.containsKey(i)) {
+        String source = map.get(i)[0];
+        String target = map.get(i)[1];
+        int currIdx = 0;
+        boolean mismatch = false;
+        while (currIdx + i < S.length() && currIdx < source.length()) {
+          if (source.charAt(currIdx) != S.charAt(currIdx + i)) {
+            mismatch = true;
+            break;
+          }
+          currIdx++;
         }
-        
-        StringBuilder sb = new StringBuilder();
-        for (int i=0; i<S.length(); i++) {
-            if (sourceMap.containsKey(i) && S.substring(i).startsWith(sourceMap.get(i))) {
-                sb.append(targetMap.get(i));
-                i += sourceMap.get(i).length() - 1;
-            }
-            else {
-                sb.append(S.charAt(i));
-            }
+        if (mismatch || currIdx != source.length()) {
+          sb.append(S.charAt(i));
+          continue;
         }
-        
-        return sb.toString();
+        sb.append(target);
+        i += source.length() - 1;
+      }
+      else {
+        sb.append(S.charAt(i));
+      }
     }
+    return sb.toString();
+  }
 }
diff --git a/Medium/Find the Index of the Large Integer.java b/Medium/Find the Index of the Large Integer.java
new file mode 100644
index 00000000..0b77a684
--- /dev/null
+++ b/Medium/Find the Index of the Large Integer.java	
@@ -0,0 +1,38 @@
+/**
+ * // This is ArrayReader's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface ArrayReader {
+ *     // Compares the sum of arr[l..r] with the sum of arr[x..y] 
+ *     // return 1 if sum(arr[l..r]) > sum(arr[x..y])
+ *     // return 0 if sum(arr[l..r]) == sum(arr[x..y])
+ *     // return -1 if sum(arr[l..r]) < sum(arr[x..y])
+ *     public int compareSub(int l, int r, int x, int y) {}
+ *
+ *     // Returns the length of the array
+ *     public int length() {}
+ * }
+ */
+
+class Solution {
+  public int getIndex(ArrayReader reader) {
+    int left = 0;
+    int right = reader.length() - 1;
+    while (left < right) {
+      int l = left;
+      int r = (right + left - 1) / 2;
+      int x = (right + left + 2) / 2;
+      int y = right;
+      int res = reader.compareSub(l, r, x, y);
+      if (res == 0) {
+        return (left + right) / 2;
+      }
+      else if (res == 1) {
+        right = r;
+      }
+      else {
+        left = x;
+      }
+    }
+    return left;
+  }
+}
diff --git a/Medium/Shortest Way to Form String.java b/Medium/Shortest Way to Form String.java
index e2eee944..c5f28f1f 100644
--- a/Medium/Shortest Way to Form String.java	
+++ b/Medium/Shortest Way to Form String.java	
@@ -1,24 +1,28 @@
 class Solution {
-    public int shortestWay(String source, String target) {
-        int idx = 0;
-        int count = 0;
-        int n = target.length();
-        while (idx < n) {
-            int slow = idx;
-            
-            for (char c : source.toCharArray()) {
-                if (idx < n && c == target.charAt(idx)) {
-                    idx++;
-                }
-            }
-            
-            if (slow == idx) {
-                return -1;
-            }
-            
-            count++;
+  public int shortestWay(String source, String target) {
+    int count = 1;
+    int idx = 0;
+    int n = target.length();
+    int sourceIdx = 0;
+    boolean match = false;
+    while (idx < n) {
+      if (source.charAt(sourceIdx) == target.charAt(idx)) {
+        idx++;
+        sourceIdx++;
+        match = true;
+      }
+      else {
+        sourceIdx++;
+      }
+      if (sourceIdx == source.length() && idx != n) {
+        if (!match) {
+          return -1;
         }
-        
-        return count;
+        count++;
+        sourceIdx = 0;
+        match = false;
+      }
     }
+    return count;
+  }
 }

From 1656547a76d37c90c3e6dc0a6ae14fb62a9e65d2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 31 Jul 2020 10:38:02 -0500
Subject: [PATCH 0252/2175] Modified 2 solutions

---
 ...oduct and Sum of Digits of an Integer.java |  35 ++--
 ...est Line of Consecutive One in Matrix.java | 163 +++---------------
 2 files changed, 41 insertions(+), 157 deletions(-)

diff --git a/Easy/Subtract the Product and Sum of Digits of an Integer.java b/Easy/Subtract the Product and Sum of Digits of an Integer.java
index 200b6940..462d8f60 100644
--- a/Easy/Subtract the Product and Sum of Digits of an Integer.java	
+++ b/Easy/Subtract the Product and Sum of Digits of an Integer.java	
@@ -1,26 +1,17 @@
 class Solution {
-    public int subtractProductAndSum(int n) {
-        return getProduct(n) - getSum(n);
+  public int subtractProductAndSum(int n) {
+    int sum = 0;
+    int copy = n;
+    while (copy > 0) {
+      sum += copy % 10;
+      copy /= 10;
     }
-    
-    private int getProduct(int n) {
-        if (n == 0) {
-            return 0;
-        }
-        int fact = 1;
-        while (n > 0) {
-            fact *= n % 10;
-            n /= 10;
-        }
-        return fact;
-    }
-    
-    private int getSum(int n) {
-        int sum = 0;
-        while (n > 0) {
-            sum += n % 10;
-            n /= 10;
-        }
-        return sum;
+    int prod = 1;
+    copy = n;
+    while (copy > 0) {
+      prod *= copy % 10;
+      copy /= 10;
     }
+    return prod - sum;
+  }
 }
diff --git a/Medium/Longest Line of Consecutive One in Matrix.java b/Medium/Longest Line of Consecutive One in Matrix.java
index 70dcf736..a0fcebb2 100644
--- a/Medium/Longest Line of Consecutive One in Matrix.java	
+++ b/Medium/Longest Line of Consecutive One in Matrix.java	
@@ -1,139 +1,32 @@
 class Solution {
-    public int longestLine(int[][] M) {
-        List<List<Integer>> points = new ArrayList<>();
-        for (int i=0; i<M.length; i++) {
-            for (int j=0; j<M[i].length; j++) {
-                if (M[i][j] == 1) {
-                    points.add(Arrays.asList(i, j));
-                }
-            }
-        }
-        
-        int max = 0;
-        
-        for (List<Integer> point : points) {
-            int rowCount = rowLength(M, point.get(0), point.get(1), M[0].length);
-            int colCount = colLength(M, point.get(0), point.get(1), M.length);
-            int firstDiagonalCount = firstDiagnol(M, point.get(0), point.get(1), M.length, M[0].length);
-            int secondDiagonalCount = secondDiagnol(M, point.get(0), point.get(1), M.length, M[0].length);
-            
-            int maxOnes = Math.max(Math.max(rowCount, colCount), Math.max(firstDiagonalCount, secondDiagonalCount));
-            
-            max = Math.max(max, maxOnes);
-        }
-        
-        return max;
-    }
-    
-    private int rowLength(int[][] M, int row, int col, int size) {
-        int count = 1;
-        int leftIdx = col - 1;
-        int rightIdx = col + 1;
-        
-        while (leftIdx >= 0) {
-            if (M[row][leftIdx] != 1) {
-                break;
-            }
-            
-            leftIdx--;
-            count++;
-        }
-        
-        while (rightIdx < size) {
-            if (M[row][rightIdx] != 1) {
-                break;
-            }
-            
-            rightIdx++;
-            count++;
-        }
-        
-        return count;
-    }
-    
-    private int colLength(int[][] M, int row, int col, int size) {
-        int count = 1;
-        int leftIdx = row - 1;
-        int rightIdx = row + 1;
-        
-        while (leftIdx >= 0) {
-            if (M[leftIdx][col] != 1) {
-                break;
-            }
-            
-            leftIdx--;
-            count++;
-        }
-        
-        while (rightIdx < size) {
-            if (M[rightIdx][col] != 1) {
-                break;
-            }
-            
-            rightIdx++;
-            count++;
-        }
-        
-        return count;
+  public int longestLine(int[][] M) {
+    if (M.length == 0 || M[0].length == 0) {
+      return 0;
     }
-    
-    private int firstDiagnol(int[][] M, int row, int col, int rows, int cols) {
-        int count = 1;
-        int rightRowIdx = row - 1;
-        int rightColIdx = col - 1;
-        int downRowIdx = row + 1;
-        int downColIdx = col + 1;
-        
-        while (rightRowIdx >= 0 && rightColIdx >= 0) {
-            if (M[rightRowIdx][rightColIdx] != 1) {
-                break;
-            }
-            
-            rightRowIdx--;
-            rightColIdx--;
-            count++;
-        }
-        
-        while (downRowIdx < rows && downColIdx < cols) {
-            if (M[downRowIdx][downColIdx] != 1) {
-                break;
-            }
-            
-            downRowIdx++;
-            downColIdx++;
-            count++;
-        }
-        
-        return count;
-    }
-    
-    private int secondDiagnol(int[][] M, int row, int col, int rows, int cols) {
-        int count = 1;
-        int rightRowIdx = row - 1;
-        int rightColIdx = col + 1;
-        int leftRowIdx = row + 1;
-        int leftColIdx = col - 1;
-        
-        while (rightRowIdx >= 0 && rightColIdx < cols) {
-            if (M[rightRowIdx][rightColIdx] != 1) {
-                break;
-            }
-            
-            rightRowIdx--;
-            rightColIdx++;
-            count++;
-        }
-        
-        while (leftRowIdx < rows && leftColIdx >= 0) {
-            if (M[leftRowIdx][leftColIdx] != 1) {
-                break;
-            }
-            
-            leftRowIdx++;
-            leftColIdx--;
-            count++;
-        }
-        
-        return count;
+    int maxLength = 0;
+    int rows = M.length;
+    int cols = M[0].length;
+    int[][] dirs = {{-1, 0}, {0, -1}, {-1, 1}, {-1, -1}};
+    int[][][] dp = new int[rows][cols][4];
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (M[i][j] == 1) {
+          for (int k = 0; k < 4; k++) {
+            dp[i][j][k] = 1;
+            int prevI = i + dirs[k][0];
+            int prevJ = j + dirs[k][1];
+            if (isValid(prevI, prevJ, rows, cols)) {
+              dp[i][j][k] += dp[prevI][prevJ][k];
+            }
+            maxLength = Math.max(maxLength, dp[i][j][k]);
+          }
+        }
+      }
     }
+    return maxLength;
+  }
+
+  private boolean isValid(int x, int y, int rows, int cols) {
+    return x >= 0 && x < rows && y >= 0 && y < cols;
+  }
 }

From 5a74e2046471b58b2baf04e408171b869e1dc0b6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 1 Aug 2020 12:25:55 -0500
Subject: [PATCH 0253/2175] Added 1 solution & modified 2 solutions

---
 Easy/Bulls and Cows.java                     | 25 ++++++++++++++
 Easy/Detect Capital.java                     | 31 ++++++++---------
 Medium/Bulls and Cows.java                   | 36 --------------------
 Medium/Knight Probability in Chessboard.java | 30 ++++++++++++++++
 4 files changed, 69 insertions(+), 53 deletions(-)
 create mode 100644 Easy/Bulls and Cows.java
 delete mode 100644 Medium/Bulls and Cows.java
 create mode 100644 Medium/Knight Probability in Chessboard.java

diff --git a/Easy/Bulls and Cows.java b/Easy/Bulls and Cows.java
new file mode 100644
index 00000000..5a2b5ef7
--- /dev/null
+++ b/Easy/Bulls and Cows.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public String getHint(String secret, String guess) {
+    int[] counter = new int[10];
+    int cows = 0;
+    int bulls = 0;
+    for (int i = 0; i < guess.length(); i++) {
+      int s = Character.getNumericValue(secret.charAt(i));
+      int g = Character.getNumericValue(guess.charAt(i));
+      if (s == g) {
+        bulls++;
+      }
+      else {
+        if (counter[s] < 0) {
+          cows++;
+        }
+        if (counter[g] > 0) {
+          cows++;
+        }
+        counter[s]++;
+        counter[g]--;
+      }
+    }
+    return new StringBuilder().append(bulls).append("A").append(cows).append("B").toString();
+  }
+}
diff --git a/Easy/Detect Capital.java b/Easy/Detect Capital.java
index b9431060..dafc6211 100644
--- a/Easy/Detect Capital.java	
+++ b/Easy/Detect Capital.java	
@@ -1,25 +1,22 @@
 class Solution {
   public boolean detectCapitalUse(String word) {
     int n = word.length();
-    boolean capitalFirst = Character.isUpperCase(word.charAt(0));
-    int idx = 1;
-    if (idx < n) {
-      boolean capitalSecond = Character.isUpperCase(word.charAt(idx));
-      for (idx = 1; idx < n; idx++) {
-        if (capitalFirst && capitalSecond) {
-          if (Character.isLowerCase(word.charAt(idx))) {
-            return false;
-          }
+    if (n == 0) {
+      return true;
+    }
+    boolean firstCaps = Character.isUpperCase(word.charAt(0));
+    for (int i = 1; i < n; i++) {
+      if (firstCaps) {
+        if (Character.isUpperCase(word.charAt(1)) && !Character.isUpperCase(word.charAt(i))) {
+          return false;
         }
-        else if (capitalFirst && !capitalSecond) {
-          if (Character.isUpperCase(word.charAt(idx))) {
-            return false;
-          }
+        if (!Character.isUpperCase(word.charAt(1)) && Character.isUpperCase(word.charAt(i))) {
+          return false;
         }
-        else {
-          if (Character.isUpperCase(word.charAt(idx))) {
-            return false;
-          }
+      }
+      else {
+        if (Character.isUpperCase(word.charAt(i))) {
+          return false;
         }
       }
     }
diff --git a/Medium/Bulls and Cows.java b/Medium/Bulls and Cows.java
deleted file mode 100644
index 733ab621..00000000
--- a/Medium/Bulls and Cows.java	
+++ /dev/null
@@ -1,36 +0,0 @@
-class Solution {
-    public String getHint(String secret, String guess) {
-        char[] secretChar = secret.toCharArray();
-        char[] guessChar = guess.toCharArray();
-        
-        int[] secCount = new int[10];
-        int[] guessCount = new int[10];
-        
-        for (int c : secretChar) {
-            secCount[c - '0']++;
-        }
-        
-        for (int c : guessChar) {
-            guessCount[c - '0']++;
-        }
-        
-        int sames = 0;
-        for (int i=0; i<secCount.length; i++) {
-            sames += Math.min(secCount[i], guessCount[i]);
-        }
-        
-        int numOfBulls = 0;
-        for (int i=0; i<secretChar.length; i++) {
-            if (secretChar[i] == guessChar[i]) {
-                numOfBulls++;
-            }
-        }
-        
-        int numOfCows = sames - numOfBulls;
-        
-        StringBuilder sb = new StringBuilder();
-        sb.append(numOfBulls).append("A").append(numOfCows).append("B");
-
-        return sb.toString();
-    }
-}
diff --git a/Medium/Knight Probability in Chessboard.java b/Medium/Knight Probability in Chessboard.java
new file mode 100644
index 00000000..b879c626
--- /dev/null
+++ b/Medium/Knight Probability in Chessboard.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public double knightProbability(int N, int K, int r, int c) {
+    double[][] dp = new double[N][N];
+    int[] rowMoves = new int[]{2, 2, 1, 1, -1, -1, -2, -2};
+    int[] colMoves = new int[]{1, -1, 2, -2, 2, -2, 1, -1};
+    dp[r][c] = 1;
+    while (K-- >  0) {
+      double[][] copy = new double[N][N];
+      for (int i = 0; i < N; i++) {
+        for (int j = 0; j < N; j++) {
+          for (int k = 0; k < 8; k++) {
+            int destR = i + rowMoves[k];
+            int destC = j + colMoves[k];
+            if (destR >= 0 && destR < N && destC >= 0 && destC < N) {
+              copy[destR][destC] += dp[i][j] / 8.0;
+            }
+          }
+        }
+      }
+      dp = copy;
+    }
+    double ans = 0.0;
+    for (double[] row : dp) {
+      for (double val : row) {
+        ans += val;
+      }
+    }
+    return ans;
+  }
+}

From baade582ee785828525fd73a28d30c40178191cd Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 1 Aug 2020 15:33:29 -0500
Subject: [PATCH 0254/2175] Added 2 solutions & modified 3 solutions

---
 Hard/Odd Even Jump.java                       | 59 +++++++++--------
 Medium/Increasing Triplet Subsequence.java    | 18 +++++
 .../Maximum Level Sum of a Binary Tree.java   | 65 ++++++++++---------
 Medium/Minimum Area Rectangle.java            | 29 +++++++++
 Medium/My Calendar II.java                    | 36 +++++-----
 5 files changed, 129 insertions(+), 78 deletions(-)
 create mode 100644 Medium/Increasing Triplet Subsequence.java
 create mode 100644 Medium/Minimum Area Rectangle.java

diff --git a/Hard/Odd Even Jump.java b/Hard/Odd Even Jump.java
index 8e516f6c..b5290dee 100644
--- a/Hard/Odd Even Jump.java	
+++ b/Hard/Odd Even Jump.java	
@@ -1,33 +1,36 @@
 class Solution {
-    public int oddEvenJumps(int[] A) {
-        if (A.length <= 1) {
-            return A.length;
+  public int oddEvenJumps(int[] A) {
+    int n = A.length;
+    if (n <= 1) {
+      return n;
+    }
+    boolean[] odd = new boolean[n];
+    boolean[] even = new boolean[n];
+    odd[n - 1] = even[n - 1] = true;
+    TreeMap<Integer, Integer> map = new TreeMap<>();
+    map.put(A[n - 1], n - 1);
+    int count = 0;
+    for (int i = n - 2; i >= 0; i--) {
+      int val = A[i];
+      if (map.containsKey(val)) {
+        odd[i] = even[map.get(val)];
+        even[i] = odd[map.get(val)];
+      }
+      else {
+        Integer lower = map.lowerKey(val);
+        Integer higher = map.higherKey(val);
+        if (lower != null) {
+          even[i] = odd[map.get(lower)];
         }
-        boolean[] odd = new boolean[A.length];
-        boolean[] even = new boolean[A.length];
-        odd[A.length - 1] = even[A.length - 1] = true;
-        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
-        treeMap.put(A[A.length - 1], A.length - 1);
-        int count = 0;
-        for (int i = A.length - 2; i >= 0; i--) {
-            int val = A[i];
-            if (treeMap.containsKey(val)) {
-                odd[i] = even[treeMap.get(val)];
-                even[i] = odd[treeMap.get(val)];
-            }
-            else {
-                Integer lower = treeMap.lowerKey(val);
-                Integer higher = treeMap.higherKey(val);
-                if (lower != null) {
-                    even[i] = odd[treeMap.get(lower)];
-                }
-                if (higher != null) {
-                    odd[i] = even[treeMap.get(higher)];
-                }
-            }
-            treeMap.put(val, i);
-            count += odd[i] ? 1 : 0;
+        if (higher != null) {
+          odd[i] = even[map.get(higher)];
         }
-        return count + 1;
+      }
+      map.put(val, i);
+    }
+    for (boolean b : odd) {
+      count += b ? 1 : 0;
     }
+    return count;
+  }
 }
diff --git a/Medium/Increasing Triplet Subsequence.java b/Medium/Increasing Triplet Subsequence.java
new file mode 100644
index 00000000..53e09710
--- /dev/null
+++ b/Medium/Increasing Triplet Subsequence.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public boolean increasingTriplet(int[] nums) {
+    int firstNum = Integer.MAX_VALUE;
+    int secondNum = Integer.MAX_VALUE;
+    for (int num : nums) {
+      if (num <= firstNum) {
+        firstNum = num;
+      }
+      else if (num <= secondNum) {
+        secondNum = num;
+      }
+      else {
+        return true;
+      }
+    }
+    return false;
+  }
+}
diff --git a/Medium/Maximum Level Sum of a Binary Tree.java b/Medium/Maximum Level Sum of a Binary Tree.java
index 705aae45..8c1bdac6 100644
--- a/Medium/Maximum Level Sum of a Binary Tree.java	
+++ b/Medium/Maximum Level Sum of a Binary Tree.java	
@@ -4,41 +4,44 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int maxLevelSum(TreeNode root) {
-        if (root == null) {
-            return 0;
+  public int maxLevelSum(TreeNode root) {
+    if (root == null) {
+      return 0;
+    }
+    int currLevel = 1;
+    int maxSum = Integer.MIN_VALUE;
+    int maxSumLevel = 0;
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      int currSum = 0;
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        currSum += removed.val;
+        if (removed.left != null) {
+          queue.add(removed.left);
         }
-        
-        Queue<TreeNode> queue = new LinkedList<>();
-        queue.add(root);
-        int maxSum = 0;
-        int maxLevel = 1;
-        int currLevel = 1;
-        
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            int tempSum = 0;
-            while (size-- > 0) {
-                TreeNode removed = queue.remove();
-                tempSum += removed.val;
-                if (removed.left != null) {
-                    queue.add(removed.left);
-                }
-                if (removed.right != null) {
-                    queue.add(removed.right);
-                }
-            }
-            if (maxSum < tempSum) {
-                maxSum = tempSum;
-                maxLevel = currLevel;
-            }
-            currLevel++;
+        if (removed.right != null) {
+          queue.add(removed.right);
         }
-        
-        return maxLevel;
+      }
+      if (maxSum < currSum) {
+        maxSum = currSum;
+        maxSumLevel = currLevel;
+      }
+      currLevel++;
     }
+    return maxSumLevel;
+  }
 }
diff --git a/Medium/Minimum Area Rectangle.java b/Medium/Minimum Area Rectangle.java
new file mode 100644
index 00000000..bb5bdb8c
--- /dev/null
+++ b/Medium/Minimum Area Rectangle.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int minAreaRect(int[][] points) {
+    Map<Integer, List<Integer>> rows = new TreeMap();
+    // Map of key as x coordinate and value as list of y coordinates
+    for (int[] point: points) {
+      int x = point[0];
+      int y = point[1];
+      rows.computeIfAbsent(x, k -> new ArrayList()).add(y);
+    }
+    int ans = Integer.MAX_VALUE;
+    Map<String, Integer> lastX = new HashMap();
+    for (int x: rows.keySet()) {
+      List<Integer> row = rows.get(x);
+      Collections.sort(row);
+      for (int i = 0; i < row.size(); ++i) {
+        for (int j = i + 1; j < row.size(); ++j) {
+          int y1 = row.get(i);
+          int y2 = row.get(j);
+          String code = y1 + ":" + y2;
+          if (lastX.containsKey(code)) {
+            ans = Math.min(ans, (x - lastX.get(code)) * (y2 - y1));
+          }
+          lastX.put(code, x);
+        }
+      }
+    }
+    return ans < Integer.MAX_VALUE ? ans : 0;
+  }
+}
diff --git a/Medium/My Calendar II.java b/Medium/My Calendar II.java
index ece26a8f..4eb4e177 100644
--- a/Medium/My Calendar II.java	
+++ b/Medium/My Calendar II.java	
@@ -1,25 +1,23 @@
 class MyCalendarTwo {
-    private List<int[]> books = new ArrayList<>();  
-    
-    public boolean book(int s, int e) {
-        
-        MyCalendar overlaps = new MyCalendar();
-        for (int[] b : books)
-            if (Math.max(b[0], s) < Math.min(b[1], e))
-                if (!overlaps.book(Math.max(b[0], s), Math.min(b[1], e))) return false;
-        books.add(new int[]{ s, e });
-        return true;
-    }
+  TreeMap<Integer, Integer> map;
+  public MyCalendarTwo() {
+    map = new TreeMap<>();
+  }
 
-    private static class MyCalendar {
-        List<int[]> books = new ArrayList<>();
-        public boolean book(int start, int end) {
-            for (int[] b : books)
-                if (Math.max(b[0], start) < Math.min(b[1], end)) return false;
-            books.add(new int[]{ start, end });
-            return true;
-        }
+  public boolean book(int start, int end) {
+    map.put(start, map.getOrDefault(start, 0) + 1);
+    map.put(end, map.getOrDefault(end, 0) - 1);
+    int eventCount = 0;
+    for (int val : map.values()) {
+      eventCount += val;
+      if (eventCount >= 3) {
+        map.put(start, map.get(start) - 1);
+        map.put(end, map.get(end) + 1);
+        return false;
+      }
     }
+    return true;
+  }
 }
 
 /**

From 9d031e0a6b94cd06eacd3835f950feff47e9f962 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 2 Aug 2020 11:52:11 -0500
Subject: [PATCH 0255/2175] Modifed 2 solutions

---
 Easy/Design HashSet.java          | 149 +++++++++++++++++++++++++-----
 Medium/Group Shifted Strings.java |  48 +++-------
 2 files changed, 143 insertions(+), 54 deletions(-)

diff --git a/Easy/Design HashSet.java b/Easy/Design HashSet.java
index 7bad79cc..a8cb00ad 100644
--- a/Easy/Design HashSet.java	
+++ b/Easy/Design HashSet.java	
@@ -1,32 +1,139 @@
 class MyHashSet {
 
-    /** Initialize your data structure here. */
-    List<Integer> list;
-    public MyHashSet() {
-        list = new ArrayList<>();
+  /** Initialize your data structure here. */
+  private Bucket[] bucketArray;
+  private int keyRange;
+  public MyHashSet() {
+    this.keyRange = 769;
+    this.bucketArray = new Bucket[this.keyRange];
+    for (int i = 0; i < this.keyRange; i++) {
+      this.bucketArray[i] = new Bucket();
     }
-    
-    public void add(int key) {
-        if (!list.contains(key)) {
-            list.add(key);
-        }
+  }
+  
+  protected int _hash(int key) {
+    return key % this.keyRange;
+  }
+
+  public void add(int key) {
+    int bucketIndex = this._hash(key);
+    this.bucketArray[bucketIndex].insert(key);
+  }
+
+  public void remove(int key) {
+    int bucketIndex = this._hash(key);
+    this.bucketArray[bucketIndex].delete(key);
+  }
+
+  /** Returns true if this set contains the specified element */
+  public boolean contains(int key) {
+    int bucketIndex = this._hash(key);
+    return this.bucketArray[bucketIndex].exists(key);
+  }
+}
+
+
+class Bucket {
+  private BSTree tree;
+  
+  public Bucket() {
+    tree = new BSTree();
+  }
+  
+  public void insert(Integer key) {
+    this.tree.root = this.tree.insertToBST(this.tree.root, key);
+  }
+  
+  public void delete(Integer key) {
+    this.tree.root = this.tree.deleteFromBST(this.tree.root, key);
+  }
+  
+  public boolean exists(Integer key) {
+    TreeNode node = this.tree.searchBST(this.tree.root, key);
+    return node != null;
+  }
+}
+
+
+class BSTree {
+  TreeNode root = null;
+  
+  public TreeNode searchBST(TreeNode root, int val) {
+    if (root == null || val == root.val) {
+      return root;
+    }
+    return root.val > val ? searchBST(root.left, val) : searchBST(root.right, val);
+  }
+  
+  public TreeNode insertToBST(TreeNode root, int val) {
+    if (root == null) {
+      return new TreeNode(val);
     }
     
-    public void remove(int key) {
-        Iterator<Integer> it = list.iterator();
-        while(it.hasNext()) {
-            int val = it.next();
-            if (val == key) {
-                it.remove();
-                return;
-            }
-        }
+    if (root.val < val) {
+      root.right = insertToBST(root.right, val);
     }
+    else if (root.val > val) {
+      root.left = insertToBST(root.left, val);
+    }
+    else {
+      return root;
+    }
+    return root;
+  }
+  
+  public TreeNode deleteFromBST(TreeNode root, int key) {
+    if (root == null) {
+      return null;
+    }
+    if (root.val < key) {
+      root.right = deleteFromBST(root.right, key);
+    }
+    else if (root.val > key) {
+      root.left = deleteFromBST(root.left, key);
+    }
+    else {
+      if (root.left == null && root.right == null) {
+        root = null;
+      }
+      else if (root.right != null) {
+        root.val = successor(root);
+        root.right = deleteFromBST(root.right, root.val);
+      }
+      else {
+        root.val = predecessor(root);
+        root.left = deleteFromBST(root.left, root.val);
+      }
+    }
+    return root;
+  }
+  
+  private int successor(TreeNode root) {
+    root = root.right;
+    while (root.left != null) {
+      root = root.left;
+    }
+    return root.val;
+  }
     
-    /** Returns true if this set did not already contain the specified element */
-    public boolean contains(int key) {
-        return list.contains(key);
+  private int predecessor(TreeNode root) {
+    root = root.left;
+    while (root.right != null) {
+      root = root.right;
     }
+    return root.val;
+  }
+}
+
+
+class TreeNode {
+  int val;
+  TreeNode left;
+  TreeNode right;
+  
+  public TreeNode(int x) {
+    val = x;
+  }
 }
 
 /**
diff --git a/Medium/Group Shifted Strings.java b/Medium/Group Shifted Strings.java
index aa280633..2207727c 100644
--- a/Medium/Group Shifted Strings.java	
+++ b/Medium/Group Shifted Strings.java	
@@ -1,37 +1,19 @@
 class Solution {
-    public static List<List<String>> groupStrings(String[] strings) {
-        Map<String, List<String>> map = new HashMap<>();
-
-        for (String s : strings) {
-            String key = getKey(s);
-
-            if (map.containsKey(key)) {
-                map.get(key).add(s);
-            }
-            else {
-                List<String> list = new ArrayList<>();
-                list.add(s);
-                map.put(key, list);
-            }
-        }
-
-        List<List<String>> ans = new ArrayList<>();
-        for (List<String> list : map.values()) {
-            ans.add(list);
-        }
-
-        return ans;
+  public List<List<String>> groupStrings(String[] strings) {
+    Map<String, List<String>> map = new HashMap<>();
+    for (String str : strings) {
+      map.computeIfAbsent(getKey(str), k -> new ArrayList<>()).add(str);
     }
-
-    private static String getKey(String s) {
-        StringBuilder sb = new StringBuilder("");
-        for (int i=1; i<s.length(); i++) {
-            int diff = s.charAt(i) - s.charAt(i-1);
-            diff = diff < 0 ? diff + 26 : diff;
-
-            sb.append(diff);
-        }
-
-        return sb.toString();
+    return new ArrayList<>(map.values());
+  }
+  
+  private String getKey(String s) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 1; i < s.length(); i++) {
+      int diff = s.charAt(i) - s.charAt(i - 1);
+      diff = diff < 0 ? diff + 26 : diff;
+      sb.append(diff);
     }
+    return sb.toString();
+  }
 }

From d05fd27d5e5a912c964a11d63ade006c3742b702 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 2 Aug 2020 19:47:42 -0500
Subject: [PATCH 0256/2175] Modified 2 solutions

---
 Easy/String Compression.java | 42 ++++++++++++++++------------------
 Medium/Kill Process.java     | 44 +++++++++++++++++-------------------
 2 files changed, 40 insertions(+), 46 deletions(-)

diff --git a/Easy/String Compression.java b/Easy/String Compression.java
index 6a13ffb1..6b21d22e 100644
--- a/Easy/String Compression.java	
+++ b/Easy/String Compression.java	
@@ -1,27 +1,23 @@
 class Solution {
-    public int compress(char[] chars) {
-        
-        int ans = 0;
-        int ind = 0;
-        
-        while (ind < chars.length) {
-            char currChar = chars[ind];
-            int count = 0;
-            
-            while(ind < chars.length && chars[ind] == currChar) {
-                ind++;
-                count++;
-            }
-            
-            chars[ans++] = currChar;
-            
-            if (count != 1) {
-                for (char c : Integer.toString(count).toCharArray()) {
-                    chars[ans++] = c;
-                }
-            }
+  public int compress(char[] chars) {
+    int start = 0;
+    int end = 0;
+    int n = chars.length;
+    while (end < n) {
+      char c = chars[end];
+      int count = 0;
+      while (end < n && chars[end] == c) {
+        end++;
+        count++;
+      }
+      chars[start++] = c;
+      if (count > 1) {
+        String countStr = String.valueOf(count);
+        for (char countC : countStr.toCharArray()) {
+          chars[start++] = countC;
         }
-        
-        return ans;
+      }
     }
+    return start;
+  }
 }
diff --git a/Medium/Kill Process.java b/Medium/Kill Process.java
index 8279a01c..623bf04f 100644
--- a/Medium/Kill Process.java	
+++ b/Medium/Kill Process.java	
@@ -1,27 +1,25 @@
 class Solution {
-    public List<Integer> killProcess(List<Integer> pid, List<Integer> ppid, int kill) {
-        
-        // Parent -> Children Map
-        Map<Integer, List<Integer>> map = new HashMap<>();
-        for (int i=0; i<pid.size(); i++) {
-            map.computeIfAbsent(ppid.get(i), e -> new ArrayList<>()).add(pid.get(i));
-        }
-        
-        
-        List<Integer> processesKilled = new ArrayList<>();
-        Queue<Integer> queue = new LinkedList<>();
-        queue.add(kill);
-        
-        while (!queue.isEmpty()) {
-            int process = queue.remove();
-            processesKilled.add(process);
-            List<Integer> childrens = map.getOrDefault(process, new ArrayList<>());
-            
-            for (Integer child : childrens) {
-                queue.add(child);
-            }
+  public List<Integer> killProcess(List<Integer> pid, List<Integer> ppid, int kill) {
+    Map<Integer, List<Integer>> map = new HashMap<>();
+    for (int i = 0; i < pid.size(); i++) {
+      if (ppid.get(i) != 0) {
+        map.computeIfAbsent(ppid.get(i), k -> new ArrayList<>()).add(pid.get(i));
+      }
+    }
+    Set<Integer> set = new HashSet<>();
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(kill);
+    set.add(kill);
+    while (!queue.isEmpty()) {
+      int removed = queue.remove();
+      set.add(removed);
+      for (Integer child : map.getOrDefault(removed, new ArrayList<>())) {
+        if (!set.contains(child)) {
+          queue.add(child);
+          set.add(child);
         }
-        
-        return processesKilled;
+      }
     }
+    return new ArrayList<>(set);
+  }
 }

From 70fa6623e4508e0bcb84d666e5b4941096da1aa5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 3 Aug 2020 10:30:01 -0500
Subject: [PATCH 0257/2175] Added 2 solutions & modified 3 solutions

---
 Hard/Binary Tree Maximum Path Sum.java | 42 ++++++++++++++------------
 Medium/Binary Tree Coloring Game.java  | 38 +++++++++++++++++++++++
 Medium/Campus Bikes II.java            | 30 ++++++++++++++++++
 Medium/Course Schedule.java            | 33 ++++++++++----------
 Medium/Perfect Squares.java            | 42 +++++++++++++++-----------
 5 files changed, 133 insertions(+), 52 deletions(-)
 create mode 100644 Medium/Binary Tree Coloring Game.java
 create mode 100644 Medium/Campus Bikes II.java

diff --git a/Hard/Binary Tree Maximum Path Sum.java b/Hard/Binary Tree Maximum Path Sum.java
index c53cb7d0..3e143413 100644
--- a/Hard/Binary Tree Maximum Path Sum.java	
+++ b/Hard/Binary Tree Maximum Path Sum.java	
@@ -4,27 +4,31 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    int maxDownVal;
-    public int maxPathSum(TreeNode root) {
-        maxDownVal = Integer.MIN_VALUE;
-        updateVal(root);
-        return maxDownVal;
-    }
-    
-    private int updateVal(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        
-        int left = Math.max(0, updateVal(root.left));
-        int right = Math.max(0, updateVal(root.right));
-        
-        maxDownVal = Math.max(maxDownVal, left+right+root.val);
-        
-        return Math.max(left, right) + root.val;
+  int maxVal;
+  public int maxPathSum(TreeNode root) {
+    maxVal = Integer.MIN_VALUE;
+    helper(root);
+    return maxVal;
+  }
+  
+  private int helper(TreeNode root) {
+    if (root == null) {
+      return 0;
     }
+    int left = Math.max(helper(root.left), 0);
+    int right = Math.max(helper(root.right), 0);
+    int sum = root.val + left + right;
+    maxVal = Math.max(maxVal, sum);
+    return root.val + Math.max(left, right);
+  }
 }
diff --git a/Medium/Binary Tree Coloring Game.java b/Medium/Binary Tree Coloring Game.java
new file mode 100644
index 00000000..77a4d9e2
--- /dev/null
+++ b/Medium/Binary Tree Coloring Game.java	
@@ -0,0 +1,38 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  int leftCount;
+  int rightCount;
+  public boolean btreeGameWinningMove(TreeNode root, int n, int x) {
+    leftCount = 0;
+    rightCount = 0;
+    countNodes(root, x);
+    return Math.max(Math.max(leftCount, rightCount), n - leftCount - rightCount - 1) > n / 2;
+  }
+  
+  private int countNodes(TreeNode root, int x) {
+    if (root == null) {
+      return 0;
+    }
+    int l = countNodes(root.left, x);
+    int r = countNodes(root.right, x);
+    if (root.val == x) {
+      leftCount = l;
+      rightCount = r;
+    }
+    return l + r + 1;
+  }
+}
diff --git a/Medium/Campus Bikes II.java b/Medium/Campus Bikes II.java
new file mode 100644
index 00000000..82de40c4
--- /dev/null
+++ b/Medium/Campus Bikes II.java	
@@ -0,0 +1,30 @@
+class Solution {
+  int minDist;
+  public int assignBikes(int[][] workers, int[][] bikes) {
+    minDist = Integer.MAX_VALUE;
+    dfs(new boolean[bikes.length], workers, 0, bikes, 0);
+    return minDist;
+  }
+  
+  private void dfs(boolean[] visited, int[][] workers, int currIdx, int[][] bikes, int distance) {
+    if (currIdx >= workers.length) {
+      minDist = Math.min(minDist, distance);
+      return;
+    }
+    if (distance > minDist) {
+      return;
+    }
+    for (int i = 0; i < bikes.length; i++) {
+      if (visited[i]) {
+        continue;
+      }
+      visited[i] = true;
+      dfs(visited, workers, currIdx + 1, bikes, distance + getManahattanDist(bikes[i], workers[currIdx]));
+      visited[i] = false;
+    }
+  }
+  
+  private int getManahattanDist(int[] p1, int[] p2) {
+    return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
+  }
+}
diff --git a/Medium/Course Schedule.java b/Medium/Course Schedule.java
index b1eadebb..bea1a964 100644
--- a/Medium/Course Schedule.java	
+++ b/Medium/Course Schedule.java	
@@ -1,28 +1,29 @@
 class Solution {
-  Set<Integer> set = new HashSet<>();
   public boolean canFinish(int numCourses, int[][] prerequisites) {
     Map<Integer, Set<Integer>> map = new HashMap<>();
+    int[] indegree = new int[numCourses];
     for (int[] prerequisite : prerequisites) {
-      map.computeIfAbsent(prerequisite[0], k -> new HashSet<>()).add(prerequisite[1]);
+      map.computeIfAbsent(prerequisite[1], k -> new HashSet<>()).add(prerequisite[0]);
+      indegree[prerequisite[0]]++;
     }
+    Queue<Integer> queue = new LinkedList<>();
+    Set<Integer> taken = new HashSet<>();
     for (int i = 0; i < numCourses; i++) {
-      set.clear();
-      dfs(map, i);
-      if (set.contains(i)) {
-        return false;
+      if (indegree[i] == 0) {
+        queue.add(i);
+        taken.add(i);
       }
     }
-    return true;
-  }
-  
-  private void dfs(Map<Integer, Set<Integer>> map, int num) {
-    Iterator<Integer> iter = map.getOrDefault(num, new HashSet<>()).iterator();
-    while (iter.hasNext()) {
-      int course = iter.next();
-      if (!set.contains(course)) {
-        set.add(course);
-        dfs(map, course);
+    while (!queue.isEmpty()) {
+      int removed = queue.remove();
+      for (Integer dependentCourse : map.getOrDefault(removed, new HashSet<>())) {
+        indegree[dependentCourse]--;
+        if (indegree[dependentCourse] == 0) {
+          taken.add(dependentCourse);
+          queue.add(dependentCourse);
+        }
       }
     }
+    return taken.size() == numCourses;
   }
 }
diff --git a/Medium/Perfect Squares.java b/Medium/Perfect Squares.java
index 510a9c57..f0b9fb81 100644
--- a/Medium/Perfect Squares.java	
+++ b/Medium/Perfect Squares.java	
@@ -1,20 +1,28 @@
 class Solution {
-    public int numSquares(int n) {
-        int[] dp = new int[n + 1];
-        dp[0] = 0;
-        
-        for (int i = 1; i <= n; i++) {
-            int min = Integer.MAX_VALUE;
-            int j = 1;
-            
-            while (i - j*j >= 0) {
-                min = Math.min(min, dp[i - j*j] + 1);
-                j++;
-            }
-            
-            dp[i] = min;
-        }
-        
-        return dp[n];
+  Set<Integer> squareNums;
+  public int numSquares(int n) {
+    squareNums = new HashSet<>();
+    for (int i = 1; i * i <= n; i++) {
+      squareNums.add(i * i);
     }
+    int count = 1;
+    for (count = 1; count <= n; count++) {
+      if (isDividedBy(n, count)) {
+        return count;
+      }
+    }
+    return count;
+  }
+  
+  private boolean isDividedBy(int n, int count) {
+    if (count == 1) {
+      return squareNums.contains(n);
+    }
+    for (Integer squareNum : squareNums) {
+      if (isDividedBy(n - squareNum, count - 1)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }

From 353e58de64c810c92b5332be79ccd82d8d10f45e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 3 Aug 2020 19:30:18 -0500
Subject: [PATCH 0258/2175] Added 1 solution & modified 3 solutions

---
 .../Maximum of Absolute Value Expression.java | 18 ++++++++
 Medium/Missing Element in Sorted Array.java   | 44 +++++++++----------
 Medium/Palindromic Substrings.java            | 28 +++++-------
 Medium/Uncrossed Lines.java                   | 40 ++++++++---------
 4 files changed, 70 insertions(+), 60 deletions(-)
 create mode 100644 Medium/Maximum of Absolute Value Expression.java

diff --git a/Medium/Maximum of Absolute Value Expression.java b/Medium/Maximum of Absolute Value Expression.java
new file mode 100644
index 00000000..96291add
--- /dev/null
+++ b/Medium/Maximum of Absolute Value Expression.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int maxAbsValExpr(int[] arr1, int[] arr2) {
+    int res = 0;
+    int n = arr1.length;
+    int[] dirs = {-1,1};
+    for (int dir1 : dirs) {
+      for (int dir2 : dirs) {
+        int closest = dir1 * arr1[0] + dir2 * arr2[0] + 0;
+        for (int i = 1; i < n; ++i) {
+          int cur = dir1 * arr1[i] + dir2 * arr2[i] + i;
+          res = Math.max(res, cur - closest);
+          closest = Math.min(closest, cur);
+        }
+      }
+    }
+    return res;
+  }
+}
diff --git a/Medium/Missing Element in Sorted Array.java b/Medium/Missing Element in Sorted Array.java
index d9d8beb2..984822a7 100644
--- a/Medium/Missing Element in Sorted Array.java	
+++ b/Medium/Missing Element in Sorted Array.java	
@@ -1,26 +1,24 @@
 class Solution {
-    public int missingElement(int[] nums, int k) {
-        int idx = 0;
-        while (idx < nums.length - 1) {
-            if (nums[idx] != nums[idx + 1] - 1) {
-                int diff = nums[idx + 1] - nums[idx] - 1;
-                if (diff >= k) {
-                    int step = nums[idx] + 1;
-                    while (k > 1) {
-                        step++;
-                        k--;
-                    }
-                    
-                    return step;
-                }
-                else {
-                    k -= diff;
-                }
-            }
-            
-            idx++;
-        }
-        
-        return nums[nums.length - 1] + k;
+  public int missingElement(int[] nums, int k) {
+    int n = nums.length;
+    if (k > missing(n - 1,  nums)) {
+      return nums[n - 1] + k - missing(n - 1, nums);
     }
+    int start = 0;
+    int end = n - 1;
+    while (start < end) {
+      int mid = start + (end - start) / 2;
+      if (missing(mid, nums) < k) {
+        start = mid + 1;
+      }
+      else {
+        end = mid;
+      }
+    }
+    return nums[start - 1] + k - missing(start - 1, nums);
+  }
+  
+  private int missing(int idx, int[] nums) {
+    return nums[idx] - nums[0] - idx;
+  }
 }
diff --git a/Medium/Palindromic Substrings.java b/Medium/Palindromic Substrings.java
index d77a04ef..6532847b 100644
--- a/Medium/Palindromic Substrings.java	
+++ b/Medium/Palindromic Substrings.java	
@@ -1,20 +1,16 @@
 class Solution {
-    public int countSubstrings(String s) {
-        int count = 0;
-        for (int i=0;i<s.length();i++) {
-            for (int j=i;j<s.length();j++) {
-                if(isPalindrome(s.substring(i,j+1))) {
-                    count++;
-                }
-            }
+  public int countSubstrings(String s) {
+    int N = s.length();
+    int ans = 0;
+    for (int center = 0; center <= 2 * N - 1; ++center) {
+        int left = center / 2;
+        int right = left + center % 2;
+        while (left >= 0 && right < N && s.charAt(left) == s.charAt(right)) {
+            ans++;
+            left--;
+            right++;
         }
-        
-        return count;
-    }
-    
-    public boolean isPalindrome(String s) {
-        StringBuilder sb = new StringBuilder("");
-        sb.append(s);
-        return sb.reverse().toString().equals(s);
     }
+    return ans;
+  }
 }
diff --git a/Medium/Uncrossed Lines.java b/Medium/Uncrossed Lines.java
index 362e6606..6a923dfa 100644
--- a/Medium/Uncrossed Lines.java	
+++ b/Medium/Uncrossed Lines.java	
@@ -1,25 +1,23 @@
 class Solution {
-    public int maxUncrossedLines(int[] A, int[] B) {
-        Integer[][] dp = new Integer[A.length][B.length];
-        return helper(A, 0, B, 0, dp);
+  Integer[][] dp;
+  public int maxUncrossedLines(int[] A, int[] B) {
+    dp = new Integer[A.length][B.length];
+    return helper(A, 0, B, 0);
+  } 
+  
+  private int helper(int[] A, int idxA, int[] B, int idxB) {
+    if (idxA == A.length || idxB == B.length) {
+      return 0;
+    } 
+    if (dp[idxA][idxB] != null) {
+      return dp[idxA][idxB];
     }
-    
-    private int helper(int[] A, int i, int[] B, int j, Integer[][] dp) {
-        if (i >= A.length || j >= B.length) {
-            return 0;
-        }
-        
-        if (dp[i][j] != null) {
-            return dp[i][j];
-        }
-        
-        if (A[i] == B[j]) {
-            dp[i][j] = 1 + helper(A, i + 1, B, j + 1, dp);
-        }
-        else {
-            dp[i][j] = Math.max(helper(A, i + 1, B, j, dp), helper(A, i, B, j + 1, dp));
-        }
-        
-        return dp[i][j];
+    if (A[idxA] == B[idxB]) {
+      dp[idxA][idxB] = 1 + helper(A, idxA + 1, B, idxB + 1);
     }
+    else {
+      dp[idxA][idxB] = Math.max(helper(A, idxA + 1, B, idxB), helper(A, idxA, B, idxB + 1));
+    }
+    return dp[idxA][idxB];
+  }
 }

From 712e6dffd99b44b9a99ccf11afb62c163660ce09 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 4 Aug 2020 08:10:35 -0500
Subject: [PATCH 0259/2175] Added 1 solution & modified 1 solution

---
 Easy/Power of four.java                       | 19 +++++++++--
 ...Paths from Source Lead to Destination.java | 33 +++++++++++++++++++
 2 files changed, 50 insertions(+), 2 deletions(-)
 create mode 100644 Medium/All Paths from Source Lead to Destination.java

diff --git a/Easy/Power of four.java b/Easy/Power of four.java
index 04e93000..254d5097 100644
--- a/Easy/Power of four.java	
+++ b/Easy/Power of four.java	
@@ -1,5 +1,20 @@
 class Solution {
-    public boolean isPowerOfFour(int num) {
-        return num>0 && (num&(num - 1))== 0 && (num-1)%3 == 0;
+  public boolean isPowerOfFour(int num) {
+    long start = 0;
+    long end = num / 4;
+    while (start <= end) {
+      long mid = (start + end) / 2;
+      long pow = (long) Math.pow(4, mid);
+      if (pow == (long) num) {
+        return true;
+      }
+      else if (pow > (long) num) {
+        end = mid - 1;
+      }
+      else {
+        start = mid + 1;
+      }
     }
+    return false;
+  }
 }
diff --git a/Medium/All Paths from Source Lead to Destination.java b/Medium/All Paths from Source Lead to Destination.java
new file mode 100644
index 00000000..c07a22ed
--- /dev/null
+++ b/Medium/All Paths from Source Lead to Destination.java	
@@ -0,0 +1,33 @@
+class Solution {
+  enum State { 
+    PROCESSING, 
+    PROCESSED 
+  }
+  
+  public boolean leadsToDestination(int n, int[][] edges, int source, int destination) {
+    Map<Integer, Set<Integer>> graph = new HashMap<>();
+    for (int[] edge : edges) {
+      graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+    }
+    return leadsToDestinationHelper(graph, source, destination, new State[n]);
+  }
+  
+  private boolean leadsToDestinationHelper(
+    Map<Integer, Set<Integer>> graph, int source, int destination, State[] states
+  ) {
+    if (states[source] != null) {
+      return states[source] == State.PROCESSED;
+    }
+    if (!graph.containsKey(source)) {
+      return source == destination;
+    }
+    states[source] = State.PROCESSING;
+    for (Integer child : graph.getOrDefault(source, new HashSet<>())) {
+      if (!leadsToDestinationHelper(graph, child, destination, states)) {
+        return false;
+      }
+    }
+    states[source] = State.PROCESSED;
+    return true;
+  }
+}

From 348741df10cffd272346bdbc1eb3476c77599de6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 5 Aug 2020 06:54:55 -0500
Subject: [PATCH 0260/2175] Added 1 solution & modified 3 solutions

---
 Hard/Find Median From Data Stream.java | 54 +++++++---------
 Hard/Remove Invalid Parentheses.java   | 44 +++++++++++++
 Medium/Number of Islands.java          | 40 +++++++-----
 Medium/Word Ladder.java                | 85 ++++++++++++--------------
 4 files changed, 129 insertions(+), 94 deletions(-)
 create mode 100644 Hard/Remove Invalid Parentheses.java

diff --git a/Hard/Find Median From Data Stream.java b/Hard/Find Median From Data Stream.java
index 85ef83f0..a62a5e96 100644
--- a/Hard/Find Median From Data Stream.java	
+++ b/Hard/Find Median From Data Stream.java	
@@ -1,42 +1,30 @@
-lass MedianFinder {
+class MedianFinder {
 
-    /** initialize your data structure here. */
-    PriorityQueue<Integer> maxHeap;
-    PriorityQueue<Integer> minHeap;
+  /** initialize your data structure here. */
+  PriorityQueue<Integer> smaller;
+  PriorityQueue<Integer> bigger;
+  public MedianFinder() {
+    smaller = new PriorityQueue<>((a, b) -> b - a);
+    bigger = new PriorityQueue<>();
+  }
 
-    public MedianFinder() {
-        maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
-            @Override
-            public int compare(Integer o1, Integer o2) {
-                return o1 - o2;
-            }
-        });
-
-        minHeap = new PriorityQueue<>(new Comparator<Integer>() {
-            @Override
-            public int compare(Integer o1, Integer o2) {
-                return o2 - o1;
-            }
-        });
+  public void addNum(int num) {
+    smaller.add(num);
+    bigger.add(smaller.poll());
+    if (smaller.size() < bigger.size()) {
+        smaller.add(bigger.poll());
     }
+  }
 
-    public void addNum(int num) {
-        maxHeap.offer(num);
-        minHeap.offer(maxHeap.poll());
-
-        if (maxHeap.size() < minHeap.size()) {
-            maxHeap.offer(minHeap.poll());
-        }
+  public double findMedian() {
+    if (smaller.size() == 0 && bigger.size() == 0) {
+      return 0.0;
     }
-
-    public double findMedian() {
-        if (maxHeap.size() == minHeap.size()) {
-            return (double) (maxHeap.peek() + minHeap.peek())/2;
-        }
-        else {
-            return maxHeap.peek();
-        }
+    if (smaller.size() > bigger.size()) {
+      return (double) smaller.peek();
     }
+    return ((double) smaller.peek() + bigger.peek()) / 2;
+  }
 }
 
 /**
diff --git a/Hard/Remove Invalid Parentheses.java b/Hard/Remove Invalid Parentheses.java
new file mode 100644
index 00000000..843bf157
--- /dev/null
+++ b/Hard/Remove Invalid Parentheses.java	
@@ -0,0 +1,44 @@
+class Solution {
+  Set<String> validStrings;
+  int minimumRemoved;
+  public List<String> removeInvalidParentheses(String s) {
+    validStrings = new HashSet<>();
+    minimumRemoved = Integer.MAX_VALUE;
+    backtrack(s, 0, 0, 0, new StringBuilder(), 0);
+    return new ArrayList<>(validStrings);
+  }
+  
+  private void backtrack(String s, int idx, int leftCount, int rightCount, StringBuilder sb, int removedCount) {
+    if (idx == s.length()) {
+      if (leftCount == rightCount) {
+        if (removedCount <= minimumRemoved) {
+          String possibleAns = sb.toString();
+          if (removedCount < minimumRemoved) {
+            validStrings.clear();
+            minimumRemoved = removedCount;
+          }
+          validStrings.add(possibleAns);
+        }
+      }
+    }
+    else {
+      char c = s.charAt(idx);
+      if (c != '(' && c != ')') {
+        sb.append(c);
+        backtrack(s, idx + 1, leftCount, rightCount, sb, removedCount);
+        sb.deleteCharAt(sb.length() - 1);
+      }
+      else {
+        backtrack(s, idx + 1, leftCount, rightCount, sb, removedCount + 1);
+        sb.append(c);
+        if (c == '(') {
+          backtrack(s, idx + 1, leftCount + 1, rightCount, sb, removedCount);
+        }
+        else if (rightCount < leftCount) {
+          backtrack(s, idx + 1, leftCount, rightCount + 1, sb, removedCount);
+        }
+        sb.deleteCharAt(sb.length() - 1);
+      }
+    }
+  }
+}
diff --git a/Medium/Number of Islands.java b/Medium/Number of Islands.java
index 04ca052f..1d6c2a87 100644
--- a/Medium/Number of Islands.java	
+++ b/Medium/Number of Islands.java	
@@ -1,25 +1,35 @@
 class Solution {
-  public int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
   public int numIslands(char[][] grid) {
+    if (grid.length == 0 || grid[0].length == 0) {
+      return 0;
+    }
+    int rows = grid.length;
+    int cols = grid[0].length;
+    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    boolean[][] visited = new boolean[rows][cols];
     int count = 0;
-    for (int i = 0;  i < grid.length; i++) {
-      for (int j = 0; j < grid[0].length; j++) {
-        if (grid[i][j] == '1') {
-          dfs(grid, i, j);
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (grid[i][j] == '1' && !visited[i][j]) {
+          Queue<int[]> queue = new LinkedList<>();
+          queue.add(new int[]{i, j});
+          visited[i][j] = true;
+          while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            for (int[] dir : dirs) {
+              int newX = removed[0] + dir[0];
+              int newY = removed[1] + dir[1];
+              if (newX < 0 || newX >= rows || newY < 0 || newY >= cols || visited[newX][newY] || grid[newX][newY] == '0') {
+                continue;
+              }
+              visited[newX][newY] = true;
+              queue.add(new int[]{newX, newY});
+            }
+          }
           count++;
         }
       }
     }
     return count;
   }
-  
-  private void dfs(char[][] grid, int i, int j) {
-    if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') {
-      return;
-    }
-    grid[i][j] = '0';
-    for (int[] dir : dirs) {
-      dfs(grid, i + dir[0], j + dir[1]);
-    }
-  }
 }
diff --git a/Medium/Word Ladder.java b/Medium/Word Ladder.java
index 3017beb1..97528684 100644
--- a/Medium/Word Ladder.java	
+++ b/Medium/Word Ladder.java	
@@ -1,52 +1,45 @@
 class Solution {
-    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
-        int l = beginWord.length();
-        Map<String, List<String>> combMap = new HashMap<>();
-        
-        for (String word : wordList) {
-            for (int i = 0; i < l; i++) {
-                String wildCardWord = word.substring(0, i) + "*" + word.substring(i + 1, l);
-                combMap.computeIfAbsent(wildCardWord, k -> new ArrayList<>()).add(word);
-            }
-        }
-        
-        Queue<WordLevel> queue = new LinkedList<>();
-        queue.add(new WordLevel(beginWord, 1));
-        
-        Set<String> visited = new HashSet<>();
-        visited.add(beginWord);
-        
-        while (!queue.isEmpty()) {
-            WordLevel removed = queue.remove();
-            String word = removed.word;
-            int level = removed.level;
-            
-            for (int i = 0; i < l; i++) {
-                String newWord = word.substring(0, i) + "*" + word.substring(i+1);
-                
-                for (String wildCardWord : combMap.getOrDefault(newWord, new ArrayList<>())) {
-                    if (wildCardWord.equals(endWord)) {
-                        return level + 1;
-                    }
-                    
-                    if (!visited.contains(wildCardWord)) {
-                        visited.add(wildCardWord);
-                        queue.add(new WordLevel(wildCardWord, level + 1));
-                    }
-                }
-            }
+  public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+    int l = beginWord.length();
+    Map<String, List<String>> map = new HashMap<>();
+    for (String word : wordList) {
+      for (int i = 0; i < l; i++) {
+        String wildCard = word.substring(0, i) + "*" + word.substring(i + 1, l);
+        map.computeIfAbsent(wildCard, k -> new ArrayList<>()).add(word);
+      }
+    }
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(new Node(beginWord, 1));
+    Set<String> visited = new HashSet<>();
+    visited.add(beginWord);
+    while (!queue.isEmpty()) {
+      Node removed = queue.remove();
+      String word = removed.word;
+      int currLevel = removed.level;
+      for (int i = 0; i < l; i++) {
+        String newWord = word.substring(0, i) + "*" + word.substring(i + 1);
+        for (String wildCard : map.getOrDefault(newWord, new ArrayList<>())) {
+          if (wildCard.equals(endWord)) {
+            return currLevel + 1;
+          }
+          if (!visited.contains(wildCard)) {
+            visited.add(wildCard);
+            queue.add(new Node(wildCard, currLevel + 1));
+          }
         }
-        
-        return 0;
+      }
     }
+    return 0;
+  }
 }
 
-class WordLevel {
-    String word;
-    int level;
-    
-    public WordLevel(String word, int level) {
-        this.word = word;
-        this.level = level;
-    }
+
+class Node {
+  String word;
+  int level;
+
+  public Node(String word, int level) {
+    this.word = word;
+    this.level = level;
+  }
 }

From 0bf67a9841d9250d05e415678a7df02fab3ec98f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 5 Aug 2020 15:09:43 -0500
Subject: [PATCH 0261/2175] Modified 6 solutions

---
 Medium/Basic Calculator II.java              | 63 +++++++---------
 Medium/Boats to Save People.java             | 29 ++++---
 Medium/Delete Node in a BST.java             | 74 ++++++++----------
 Medium/Linked List Cycle II.java             | 39 +++++-----
 Medium/Longest Well-Performing Interval.java | 41 +++++-----
 Medium/Rotate List.java                      | 79 +++++++++-----------
 6 files changed, 144 insertions(+), 181 deletions(-)

diff --git a/Medium/Basic Calculator II.java b/Medium/Basic Calculator II.java
index 8343edef..da6ae5e4 100644
--- a/Medium/Basic Calculator II.java	
+++ b/Medium/Basic Calculator II.java	
@@ -1,39 +1,34 @@
 class Solution {
-    public int calculate(String s) {
-        Stack<Integer> stack = new Stack<>();
-        int num = 0;
-        char sign = '+';
-
-        for (int i=0; i<s.length(); i++) {
-            char c = s.charAt(i);
-            if (Character.isDigit(c)) {
-                num = num * 10 + Character.getNumericValue(c);
-            }
-            
-            if (!Character.isDigit(c) && c != ' ' || i == s.length() - 1){
-                if (sign == '-') {
-                    stack.push(-num);
-                }
-                else if (sign == '+') {
-                    stack.push(num);
-                }
-                else if (sign == '*') {
-                    stack.push(stack.pop() * num);
-                }
-                else {
-                    stack.push(stack.pop() / num);
-                }
-
-                sign = c;
-                num = 0;
-            }
+  public int calculate(String s) {
+    Stack<Integer> stack = new Stack<>();
+    int num = 0;
+    char sign = '+';
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (Character.isDigit(c)) {
+        num = num * 10 + Character.getNumericValue(c);
+      }
+      if (!Character.isDigit(c) && c != ' ' || i == s.length() - 1) {
+        if (sign == '-') {
+          stack.push(-num);
         }
-
-        int res = 0;
-        while (!stack.isEmpty()) {
-            res += stack.pop();
+        else if (sign == '+') {
+          stack.push(num);
         }
-
-        return res;
+        else if (sign == '*') {
+          stack.push(stack.pop() * num);
+        }
+        else {
+          stack.push(stack.pop() / num);
+        }
+        sign = c;
+        num = 0;
+      }
+    }
+    int res = 0;
+    while (!stack.isEmpty()) {
+      res += stack.pop();
     }
+    return res;
+  }
 }
diff --git a/Medium/Boats to Save People.java b/Medium/Boats to Save People.java
index 167a9e4d..365bafc0 100644
--- a/Medium/Boats to Save People.java	
+++ b/Medium/Boats to Save People.java	
@@ -1,19 +1,16 @@
 class Solution {
-    public int numRescueBoats(int[] people, int limit) {
-        Arrays.sort(people);
-        int count = 0;
-        int start = 0;
-        int end = people.length-1;
-        
-        while (end >= start) {
-            if (people[start] + people[end] <= limit) {
-                start++;
-            }
-            
-            end--;
-            count++;
-        }
-        
-        return count;
+  public int numRescueBoats(int[] people, int limit) {
+    Arrays.sort(people);
+    int count = 0;
+    int start = 0;
+    int end = people.length - 1;
+    while (end >= start) {
+      if (people[start] + people[end] <= limit) {
+        start++;
+      }
+      end--;
+      count++;
     }
+    return count;
+  }
 }
diff --git a/Medium/Delete Node in a BST.java b/Medium/Delete Node in a BST.java
index bcd23624..8502798f 100644
--- a/Medium/Delete Node in a BST.java	
+++ b/Medium/Delete Node in a BST.java	
@@ -4,54 +4,40 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode deleteNode(TreeNode root, int key) {
-        if (root == null) {
-            return root;
-        }
-        
-        if (key < root.val) {
-            root.left = deleteNode(root.left, key);
-        }
-        else if (key > root.val) {
-            root.right = deleteNode(root.right, key);
-        }
-        else {
-            if (root.left == null || root.right == null) {
-                TreeNode temp = root.left == null ? root.right : root.left;
-                
-                if (temp == null) {
-                    return null;
-                }
-                else {
-                    return temp;
-                }
-            }
-            else {
-                TreeNode rightSuccessor = getRightSuccessor(root);
-                root.val = rightSuccessor.val;
-                root.right = deleteNode(root.right, rightSuccessor.val);
-            }
-        }
-        
-        return root;
+  public TreeNode deleteNode(TreeNode root, int key) {
+    if (root == null) {
+      return null;
     }
-    
-    private TreeNode getRightSuccessor(TreeNode node) {
-        if (node == null) {
-            return null;
-        }    
-        
-        TreeNode temp = node.right;
-        if (temp != null) {
-            while (temp.left != null) {
-                temp = temp.left;
-            }
-        }
-        
+    if (root.val > key) {
+      root.left = deleteNode(root.left, key);
+    }
+    else if (root.val < key) {
+      root.right = deleteNode(root.right, key);
+    }
+    else {
+      if (root.left == null || root.right == null) {
+        TreeNode temp = root.left == null ? root.right : root.left;
         return temp;
+      }
+      else {
+        TreeNode inorderSuccessor = root.right;
+        while (inorderSuccessor.left != null) {
+          inorderSuccessor = inorderSuccessor.left;
+        }
+        root.val = inorderSuccessor.val;
+        root.right = deleteNode(root.right, inorderSuccessor.val);
+      }
     }
+    return root;
+  }
 }
diff --git a/Medium/Linked List Cycle II.java b/Medium/Linked List Cycle II.java
index ed568031..ba59422b 100644
--- a/Medium/Linked List Cycle II.java	
+++ b/Medium/Linked List Cycle II.java	
@@ -10,23 +10,26 @@
  * }
  */
 public class Solution {
-    public ListNode detectCycle(ListNode head) {
-        ListNode slow = head;
-        ListNode fast = head;
-
-        while (fast!=null && fast.next!=null){
-            fast = fast.next.next;
-            slow = slow.next;
-
-            if (fast == slow){
-                ListNode slow2 = head; 
-                while (slow2 != slow){
-                    slow = slow.next;
-                    slow2 = slow2.next;
-                }
-                return slow;
-            }
-        }
-        return null;
+  public ListNode detectCycle(ListNode head) {
+    ListNode slow = head;
+    ListNode fast = head;
+    boolean cycle = false;
+    while (fast != null && fast.next != null) {
+      slow = slow.next;
+      fast = fast.next.next;
+      if (slow == fast) {
+        cycle = true;
+        break;
+      }
     }
+    if (!cycle) {
+      return null;
+    }
+    slow = head;
+    while (slow != fast) {
+      slow = slow.next;
+      fast = fast.next;
+    }
+    return slow;
+  }
 }
diff --git a/Medium/Longest Well-Performing Interval.java b/Medium/Longest Well-Performing Interval.java
index 145e39d5..9940463a 100644
--- a/Medium/Longest Well-Performing Interval.java	
+++ b/Medium/Longest Well-Performing Interval.java	
@@ -1,27 +1,20 @@
 class Solution {
-    public int longestWPI(int[] hours) {
-        int ans = 0;
-        int[] preComputed = new int[hours.length + 1];
-        
-        for (int i = 1; i < preComputed.length; i++) {
-            if (hours[i - 1] > 8) {
-                ans = 1;
-                preComputed[i] = preComputed[i - 1] + 1;
-            }
-            else {
-                preComputed[i] = preComputed[i - 1] - 1;
-            }
-        }
-        
-        for(int i = 0; i <= hours.length; i++){
-            for(int j = hours.length; j > i; j--){
-                if(preComputed[j]-preComputed[i] > 0){
-                    ans = Math.max(ans, j - i);
-                    break;
-                }
-            }
-        }
-        
-        return ans;
+  public int longestWPI(int[] hours) {
+    int sum = 0;
+    int maxInterval = 0;
+    boolean greaterThanEightFound = false;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < hours.length; i++) {
+      sum += hours[i] > 8 ? 1 : -1;
+      greaterThanEightFound = hours[i] > 8 ? true : greaterThanEightFound;
+      map.putIfAbsent(sum, i);
+      if (sum >= 1) {
+        maxInterval = Math.max(maxInterval, i + 1);
+      }
+      else if (map.containsKey(sum - 1)) {
+        maxInterval = Math.max(maxInterval, i - map.get(sum - 1));
+      }
     }
+    return maxInterval == 0 ? (greaterThanEightFound ? 1 : 0) : maxInterval;
+  }
 }
diff --git a/Medium/Rotate List.java b/Medium/Rotate List.java
index 647d8433..1cf4bae2 100644
--- a/Medium/Rotate List.java	
+++ b/Medium/Rotate List.java	
@@ -3,54 +3,43 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    
-    public void rotateArr(int[] arr) {
-        int temp = arr[0];
-        for (int i=1;i<arr.length;i++) {
-            int t = arr[i];
-            arr[i] = temp;
-            temp = t;
-        }
-        
-        arr[0] = temp;
+  public ListNode rotateRight(ListNode head, int k) {
+    if (head == null || head.next == null || k == 0) {
+      return head;
     }
-    
-    public ListNode rotateRight(ListNode head, int k) {
-        if (head == null || head.next == null || k == 0) return head;
-        int l = 0;
-        ListNode curr = head;
-        while (curr != null) {
-            curr = curr.next;
-            l++;
-        }
-        
-        int[] arr = new int[l];
-        curr = head;
-        
-        for (int i=0;i<l;i++) {
-            arr[i] = curr.val;
-            curr = curr.next;
-        }
-        
-        k = k%l;
-        
-        while (k > 0) {
-            rotateArr(arr);
-            k--;
-        }
-    
-        curr = head;
-        int j = 0;
-        while (curr != null) {
-            curr.val = arr[j];
-            j++;
-            curr = curr.next;
-        }
-        
-        return head;
+    ListNode curr = head;
+    // Get length of list & update the number of rotations
+    int count = 0;
+    while (curr != null) {
+      curr = curr.next;
+      count++;
     }
+    k %= count;
+    if (k == 0) {
+      return head;
+    }
+    // Move the pointer just before the rotation index
+    int stop = count - k;
+    int currCount = 1;
+    curr = head;
+    while (currCount < stop) {
+      currCount++;
+      curr = curr.next;
+    }
+    ListNode nextNode = curr.next;
+    // Detach rotation part of list and append it in the beginning of list
+    curr.next = null;
+    ListNode newHead = nextNode;
+    while (nextNode.next != null) {
+      nextNode = nextNode.next;
+    }
+    nextNode.next = head;
+    return newHead;
+  }
 }

From e96eb1960bf2bcb61bbf2bb353c5ddbe6869ae8f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 6 Aug 2020 10:20:45 -0500
Subject: [PATCH 0262/2175] Added 2 solutions & modified 1 solution

---
 .../Shortest Distance from All Buildings.java | 56 +++++++++++++++++++
 ...rch Tree to Sorted Doubly Linked List.java | 55 +++++++++---------
 Medium/Sparse Matrix Multiplication.java      | 20 +++++++
 3 files changed, 102 insertions(+), 29 deletions(-)
 create mode 100644 Hard/Shortest Distance from All Buildings.java
 create mode 100644 Medium/Sparse Matrix Multiplication.java

diff --git a/Hard/Shortest Distance from All Buildings.java b/Hard/Shortest Distance from All Buildings.java
new file mode 100644
index 00000000..3d8a0127
--- /dev/null
+++ b/Hard/Shortest Distance from All Buildings.java	
@@ -0,0 +1,56 @@
+class Solution {
+  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public int shortestDistance(int[][] grid) {
+    int numOfHouses = 0;
+    for (int i = 0; i < grid.length; i++) {
+      for (int j = 0; j < grid[0].length; j++) {
+        numOfHouses += grid[i][j] == 1 ? 1 : 0;
+      }
+    }
+    int[] distance = {Integer.MAX_VALUE};
+    for (int i = 0; i < grid.length; i++) {
+      for (int j = 0; j < grid[0].length; j++) {
+        if (grid[i][j] == 0) {
+          bfs(grid, i, j, numOfHouses, distance);
+        }
+      }
+    }
+    return distance[0] == Integer.MAX_VALUE ? -1 : distance[0];
+  }
+  
+  private void bfs(int[][] grid, int i, int j, int numOfHouses, int[] distance) {
+    int currDistance = 0;
+    int numRows = grid.length;
+    int numCols = grid[0].length;
+    int houses = 0;
+    boolean[][] visited = new boolean[numRows][numCols];
+    Queue<int[]> queue = new LinkedList<>();
+    queue.add(new int[]{i, j, 0});
+    visited[i][j] = true;
+    while (!queue.isEmpty() && houses != numOfHouses) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int[] removed = queue.remove();
+        int x = removed[0];
+        int y = removed[1];
+        if (grid[x][y] == 1) {
+          houses++;
+          currDistance += removed[2];
+        }
+        else if (grid[x][y] == 0) {
+          for (int[] dir : dirs) {
+            int newX = x + dir[0];
+            int newY = y + dir[1];
+            if (newX >= 0 && newX < numRows && newY >= 0 && newY < numCols && !visited[newX][newY]) {
+              queue.add(new int[]{newX, newY, removed[2] + 1});
+              visited[newX][newY] = true;
+            }
+          }
+        }
+      }
+    }
+    if (houses == numOfHouses) {
+      distance[0] = Math.min(distance[0], currDistance);
+    }
+  }
+}
diff --git a/Medium/Convert Binary Search Tree to Sorted Doubly Linked List.java b/Medium/Convert Binary Search Tree to Sorted Doubly Linked List.java
index 6276ea15..838934c9 100644
--- a/Medium/Convert Binary Search Tree to Sorted Doubly Linked List.java	
+++ b/Medium/Convert Binary Search Tree to Sorted Doubly Linked List.java	
@@ -7,6 +7,10 @@ class Node {
 
     public Node() {}
 
+    public Node(int _val) {
+        val = _val;
+    }
+
     public Node(int _val,Node _left,Node _right) {
         val = _val;
         left = _left;
@@ -14,36 +18,29 @@ public Node(int _val,Node _left,Node _right) {
     }
 };
 */
+
 class Solution {
-    Node prev;
-    public Node treeToDoublyList(Node r) {
-        if (r == null) {
-            return r;
-        }
-        
-        prev = null;
-        Node dummy = new Node(0);
-        prev = dummy;
-        
-        inorderHelper(r);
-        
-        prev.right = dummy.right;
-        dummy.right.left = prev;
-        
-        return dummy.right;
+  Node prev;
+  public Node treeToDoublyList(Node root) {
+    if (root == null) {
+      return root;
     }
-    
-    private void inorderHelper(Node root) {
-        if (root == null) {
-            return;
-        }
-        
-        inorderHelper(root.left);
-        
-        prev.right = root;
-        root.left = prev;
-        prev = root;
-        
-        inorderHelper(root.right);
+    Node dummy = new Node(0);
+    prev = dummy;
+    helper(root);
+    prev.right = dummy.right;
+    dummy.right.left = prev;
+    return dummy.right;
+  }
+  
+  private void helper(Node root) {
+    if (root == null) {
+      return;
     }
+    helper(root.left);
+    prev.right = root;
+    root.left = prev;
+    prev = root;
+    helper(root.right); 
+  }
 }
diff --git a/Medium/Sparse Matrix Multiplication.java b/Medium/Sparse Matrix Multiplication.java
new file mode 100644
index 00000000..e1e20566
--- /dev/null
+++ b/Medium/Sparse Matrix Multiplication.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int[][] multiply(int[][] A, int[][] B) {
+    int m = A.length;
+    int n = A[0].length;
+    int nB = B[0].length;
+    int[][] C = new int[m][nB];
+    for(int i = 0; i < m; i++) {
+      for(int k = 0; k < n; k++) {
+        if (A[i][k] != 0) {
+          for (int j = 0; j < nB; j++) {
+            if (B[k][j] != 0) {
+              C[i][j] += A[i][k] * B[k][j];
+            }
+          }
+        }
+      }
+    }
+    return C;   
+  }
+}

From 88dc7b6c2a19b1af119566b27e1e66273765227b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 7 Aug 2020 10:58:43 -0500
Subject: [PATCH 0263/2175] Added 1 solution & modified 2 solutions

---
 Easy/Average of Levels in Binary Tree.java   | 41 ++++++++++
 Easy/Average of levels in a binary tree.java | 30 -------
 Hard/Minimum Cost to Hire K Workers.java     | 43 ++++++++++
 Medium/Vowel Spellchecker.java               | 85 ++++++++------------
 4 files changed, 118 insertions(+), 81 deletions(-)
 create mode 100644 Easy/Average of Levels in Binary Tree.java
 delete mode 100644 Easy/Average of levels in a binary tree.java
 create mode 100644 Hard/Minimum Cost to Hire K Workers.java

diff --git a/Easy/Average of Levels in Binary Tree.java b/Easy/Average of Levels in Binary Tree.java
new file mode 100644
index 00000000..dad5fc3e
--- /dev/null
+++ b/Easy/Average of Levels in Binary Tree.java	
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public List<Double> averageOfLevels(TreeNode root) {
+    List<Double> averages = new ArrayList<>();
+    if (root == null) {
+      return averages;
+    }
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      long sum = 0;
+      int size = queue.size();
+      for (int i = 0; i < size; i++) {
+        TreeNode removed = queue.remove();
+        sum += removed.val;
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+      averages.add(((double) sum) / size);
+    }
+    return averages;
+  }
+}
diff --git a/Easy/Average of levels in a binary tree.java b/Easy/Average of levels in a binary tree.java
deleted file mode 100644
index 138ec958..00000000
--- a/Easy/Average of levels in a binary tree.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public List<Double> averageOfLevels(TreeNode root) {
-        List<Double> result = new ArrayList<>();
-        Queue<TreeNode> q = new LinkedList<>();
-
-        if(root == null) return result;
-        q.add(root);
-        while(!q.isEmpty()) {
-            int n = q.size();
-            double sum = 0.0;
-            for(int i = 0; i < n; i++) {
-                TreeNode node = q.poll();
-                sum += node.val;
-                if(node.left != null) q.add(node.left);
-                if(node.right != null) q.add(node.right);
-            }
-            result.add(sum / n);
-        }
-        return result;
-    }
-}
diff --git a/Hard/Minimum Cost to Hire K Workers.java b/Hard/Minimum Cost to Hire K Workers.java
new file mode 100644
index 00000000..753c5673
--- /dev/null
+++ b/Hard/Minimum Cost to Hire K Workers.java	
@@ -0,0 +1,43 @@
+class Solution {
+  public double mincostToHireWorkers(int[] quality, int[] wage, int K) {
+    int n = quality.length;
+    Worker[] workers = new Worker[n];
+    for (int i = 0; i < n; i++) {
+      workers[i] = new Worker(quality[i], wage[i]);
+    }
+    Arrays.sort(workers);
+    double ans = 1e9;
+    int sum = 0;
+    PriorityQueue<Integer> pool = new PriorityQueue<>();
+    for (Worker worker : workers) {
+      pool.offer(-worker.quality);
+      sum += worker.quality;
+      if (pool.size() > K) {
+        sum += pool.poll();
+      }
+      if (pool.size() == K) {
+        ans = Math.min(ans, sum * worker.ratio());
+      }
+    }
+    return ans;
+  }
+}
+
+
+class Worker implements Comparable<Worker> {
+  int quality;
+  int wage;
+  
+  public Worker(int quality, int wage) {
+    this.quality = quality;
+    this.wage = wage;
+  }
+  
+  public double ratio() {
+    return (double) wage / quality;
+  }
+  
+  public int compareTo(Worker other) {
+    return Double.compare(ratio(), other.ratio());
+  }
+}
diff --git a/Medium/Vowel Spellchecker.java b/Medium/Vowel Spellchecker.java
index 0d9801ee..105ad71f 100644
--- a/Medium/Vowel Spellchecker.java	
+++ b/Medium/Vowel Spellchecker.java	
@@ -1,55 +1,38 @@
 class Solution {
-    public String[] spellchecker(String[] wordlist, String[] queries) {
-        Map<String, String> caseMap = new HashMap<>();
-        Set<String> set = new HashSet<>();
-        
-        // Case Part
-        for (String word : wordlist) {
-            if (!caseMap.containsKey(word.toLowerCase())) {
-                caseMap.put(word.toLowerCase(), word);
-            }
-            
-            set.add(word);
-        }
-        
-        // Vowel Part
-        Map<String, String> vowelMap = new HashMap<>();
-        for (String word : wordlist) {
-            String genericVal = makeGenericVowel(word);
-            if (!vowelMap.containsKey(genericVal)) {
-                vowelMap.put(genericVal, word);
-            }
-        }
-        
-        String[] ans = new String[queries.length];
-        
-        for (int i=0; i<queries.length; i++) {
-            if (set.contains(queries[i])) {
-                ans[i] = queries[i];
-            }
-            else if (caseMap.containsKey(queries[i].toLowerCase())) {
-                ans[i] = caseMap.get(queries[i].toLowerCase());
-            } 
-            else if (vowelMap.containsKey(makeGenericVowel(queries[i]))) {
-                ans[i] = vowelMap.get(makeGenericVowel(queries[i]));
-            } 
-            else {
-                ans[i] = "";
-            }
-        }
-        
-        return ans;
+  public String[] spellchecker(String[] wordlist, String[] queries) {
+    Map<String, String> capsMap = new HashMap<>();
+    Map<String, String> vowMap = new HashMap<>();
+    Set<String> perfect = new HashSet<>();
+    for (String word : wordlist) {
+      perfect.add(word);
+      capsMap.putIfAbsent(word.toLowerCase(), word);
+      vowMap.putIfAbsent(getVowelKey(word.toLowerCase()), word);
     }
-    
-    private String makeGenericVowel(String s) {
-        String vowel = "aeiou";
-        char[] ch = s.toLowerCase().toCharArray();
-        for (int i=0; i<ch.length; i++) {
-            if (vowel.indexOf(ch[i]) != -1) {
-                ch[i] = '#';
-            }
-        }
-        
-        return String.valueOf(ch);
+    String[] ans = new String[queries.length];
+    for (int i = 0; i < queries.length; i++) {
+      if (perfect.contains(queries[i])) {
+        ans[i] = queries[i];
+      }
+      else if (capsMap.containsKey(queries[i].toLowerCase())) {
+        ans[i] = capsMap.get(queries[i].toLowerCase());
+      }
+      else {
+        ans[i] = vowMap.getOrDefault(getVowelKey(queries[i].toLowerCase()), "");
+      }
     }
+    return ans;
+  }
+  
+  private String getVowelKey(String word) {
+    StringBuilder sb = new StringBuilder();
+    for (char c : word.toCharArray()) {
+      if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
+        sb.append('*');
+      }
+      else {
+        sb.append(c);
+      }
+    }
+    return sb.toString();
+  }
 }

From a836a8696403b6cc40f9332ea401527c59cbd595 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 8 Aug 2020 17:19:58 -0500
Subject: [PATCH 0264/2175] Added 2 solutions & modified 1 solution

---
 Easy/Kth Missing Positive Integer.java    | 22 ++++++++++++++++
 Hard/Largest Rectangle in Histogram.java  | 31 ++++++++++-------------
 Medium/Can Convert String in K Moves.java | 24 ++++++++++++++++++
 3 files changed, 60 insertions(+), 17 deletions(-)
 create mode 100644 Easy/Kth Missing Positive Integer.java
 create mode 100644 Medium/Can Convert String in K Moves.java

diff --git a/Easy/Kth Missing Positive Integer.java b/Easy/Kth Missing Positive Integer.java
new file mode 100644
index 00000000..9721a3c4
--- /dev/null
+++ b/Easy/Kth Missing Positive Integer.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int findKthPositive(int[] arr, int k) {
+    int missCount = 0;
+    for (int i = 0; i < arr.length; i++) {
+      int curr = arr[i];
+      int prev = i == 0 ? 0 : arr[i - 1];
+      while (prev < (curr - 1)) {
+        missCount++;
+        prev++;
+        if (missCount == k) {
+          return prev;
+        }
+      }
+    }
+    int curr = arr[arr.length - 1];
+    while (missCount < k) {
+      curr++;
+      missCount++;
+    }
+    return curr;
+  }
+}
diff --git a/Hard/Largest Rectangle in Histogram.java b/Hard/Largest Rectangle in Histogram.java
index a8dde610..837baf32 100644
--- a/Hard/Largest Rectangle in Histogram.java	
+++ b/Hard/Largest Rectangle in Histogram.java	
@@ -1,20 +1,17 @@
 class Solution {
-    public int largestRectangleArea(int[] heights) {
-        Stack<Integer> stack = new Stack<>();
-        int maxArea = 0;
-        
-        for (int i = 0; i < heights.length; i++) {
-            while (!stack.isEmpty() && heights[i] < heights[stack.peek()]) {
-                maxArea = Math.max(maxArea, heights[stack.pop()] * (i - (stack.isEmpty() ? 0 : stack.peek() + 1)));
-            }    
-            
-            stack.push(i);
-        }
-        
-        while (!stack.isEmpty()) {
-            maxArea = Math.max(maxArea, heights[stack.pop()] * (heights.length - (stack.isEmpty() ? 0 : stack.peek() + 1)));
-        }
-        
-        return maxArea;
+  public int largestRectangleArea(int[] heights) {
+    Stack<Integer> stack = new Stack<>();
+    int maxArea = 0;
+    stack.push(-1);
+    for (int i = 0; i < heights.length; i++) {
+      while (stack.peek() != -1 && heights[stack.peek()] >= heights[i]) {
+        maxArea = Math.max(maxArea, heights[stack.pop()] * (i - stack.peek() - 1));
+      }
+      stack.push(i);
     }
+    while (stack.peek() != -1) {
+      maxArea = Math.max(maxArea, heights[stack.pop()] * (heights.length - stack.peek() - 1));
+    }
+    return maxArea;
+  }
 }
diff --git a/Medium/Can Convert String in K Moves.java b/Medium/Can Convert String in K Moves.java
new file mode 100644
index 00000000..fe496fbb
--- /dev/null
+++ b/Medium/Can Convert String in K Moves.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public boolean canConvertString(String s, String t, int k) {
+    if (s.length() != t.length()) {
+      return false;
+    }
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < s.length(); i++) {
+      int possibleMove = getDifference(s.charAt(i), t.charAt(i));
+      if (possibleMove > 0 && (possibleMove + map.getOrDefault(possibleMove, 0) * 26) > k) {
+        return false;
+      }
+      map.put(possibleMove, map.getOrDefault(possibleMove, 0) + 1);
+    }
+    return true;
+  }
+  
+  private int getDifference(char c1, char c2) {
+    int diff = ((int) c2) - ((int) c1);
+    if (diff >= 0) {
+      return diff;
+    }
+    return diff + 26;
+  }
+}

From 53e20c65a95df30d0f44fcb4d565a50f33e7aab3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 9 Aug 2020 07:45:01 -0500
Subject: [PATCH 0265/2175] Added 2 solutions

---
 Easy/Make The String Great.java                | 18 ++++++++++++++++++
 ...pping Subarrays With Sum Equals Target.java | 18 ++++++++++++++++++
 {Easy => Medium}/Rotting Oranges.java          |  0
 3 files changed, 36 insertions(+)
 create mode 100644 Easy/Make The String Great.java
 create mode 100644 Medium/Maximum Number of Non-Overlapping Subarrays With Sum Equals Target.java
 rename {Easy => Medium}/Rotting Oranges.java (100%)

diff --git a/Easy/Make The String Great.java b/Easy/Make The String Great.java
new file mode 100644
index 00000000..a7cb7882
--- /dev/null
+++ b/Easy/Make The String Great.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public String makeGood(String s) {
+    Stack<Character> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
+      if (!stack.isEmpty() && Math.abs(stack.peek() - c) == 32) {
+        stack.pop();
+      }
+      else {
+        stack.push(c);
+      }
+    }
+    StringBuilder sb = new StringBuilder();
+    while (!stack.isEmpty()) {
+      sb.append(stack.pop());
+    }
+    return sb.reverse().toString();
+  }
+}
diff --git a/Medium/Maximum Number of Non-Overlapping Subarrays With Sum Equals Target.java b/Medium/Maximum Number of Non-Overlapping Subarrays With Sum Equals Target.java
new file mode 100644
index 00000000..9cd5a000
--- /dev/null
+++ b/Medium/Maximum Number of Non-Overlapping Subarrays With Sum Equals Target.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int maxNonOverlapping(int[] nums, int target) {
+    int sum = 0;
+    int count = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    map.put(0, -1);
+    int lastIdx = -1;
+    for (int i = 0; i < nums.length; i++) {
+      sum += nums[i];
+      if (map.containsKey(sum - target) && map.get(sum - target) >= lastIdx) {
+        count++;
+        lastIdx = i;
+      }
+      map.put(sum, i);
+    }
+    return count;
+  }
+}
diff --git a/Easy/Rotting Oranges.java b/Medium/Rotting Oranges.java
similarity index 100%
rename from Easy/Rotting Oranges.java
rename to Medium/Rotting Oranges.java

From cbb1b6d9600725bf8e9fa1a73edb0c38d061ba60 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 10 Aug 2020 18:10:41 -0500
Subject: [PATCH 0266/2175] Added 1 solution & modified 4 solutions

---
 Easy/Robot Return to Origin.java              | 17 ++---
 Medium/Binary Search Tree Iterator.java       | 66 +++++++++++--------
 Medium/Divide Two Integers.java               | 65 ++++++++----------
 Medium/Is Graph Bipartite.java                | 44 ++++++-------
 ...tones Removed with Same Row or Column.java | 22 +++++++
 5 files changed, 116 insertions(+), 98 deletions(-)
 create mode 100644 Medium/Most Stones Removed with Same Row or Column.java

diff --git a/Easy/Robot Return to Origin.java b/Easy/Robot Return to Origin.java
index 978c30d6..e5661ac0 100644
--- a/Easy/Robot Return to Origin.java	
+++ b/Easy/Robot Return to Origin.java	
@@ -1,17 +1,14 @@
 class Solution {
-  Map<Character, int[]> map;
   public boolean judgeCircle(String moves) {
-    map = new HashMap<>();
-    map.put('U', new int[]{-1, 0});
-    map.put('D', new int[]{1, 0});
-    map.put('L', new int[]{0, -1});
-    map.put('R', new int[]{0, 1});
     int x = 0;
     int y = 0;
-    for (char c : moves.toCharArray()) {
-      int[] dir = map.get(c);
-      x += dir[0];
-      y += dir[1];
+    for (char move : moves.toCharArray()) {
+      if (move == 'U' || move == 'D') {
+        y += move == 'U' ? 1 : -1;
+      }
+      else {
+        x += move == 'L' ? -1 : 1;
+      }
     }
     return x == 0 && y == 0;
   }
diff --git a/Medium/Binary Search Tree Iterator.java b/Medium/Binary Search Tree Iterator.java
index 7dcce82e..038f4a37 100644
--- a/Medium/Binary Search Tree Iterator.java	
+++ b/Medium/Binary Search Tree Iterator.java	
@@ -1,43 +1,53 @@
 /**
- * Definition for binary tree
+ * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
-
-public class BSTIterator {
-    Stack<TreeNode> stack;
-    public BSTIterator(TreeNode root) {
-        stack = new Stack<>();
-        pushLeft(root);
+class BSTIterator {
+  Stack<TreeNode> stack;
+  public BSTIterator(TreeNode root) {
+    stack = new Stack<>();
+    update(root);
+  }
+  
+  private void update(TreeNode node) {
+    if (node == null) {
+      return;
     }
-    
-    private void pushLeft(TreeNode root) {
-        while(root != null) {
-            stack.push(root);
-            root = root.left;
-        }
+    stack.add(node);
+    TreeNode leftNode = node.left;
+    while (leftNode != null) {
+      stack.add(leftNode);
+      leftNode = leftNode.left;
     }
+  }
 
-    /** @return whether we have a next smallest number */
-    public boolean hasNext() {
-        return !stack.isEmpty();
-    }
+  /** @return the next smallest number */
+  public int next() {
+    TreeNode node = stack.pop();
+    update(node.right);
+    return node.val;
+  }
 
-    /** @return the next smallest number */
-    public int next() {
-        TreeNode node = stack.pop();
-        pushLeft(node.right);
-        
-        return node.val;
-    }
+  /** @return whether we have a next smallest number */
+  public boolean hasNext() {
+    return !stack.isEmpty();
+  }
 }
 
 /**
- * Your BSTIterator will be called like this:
- * BSTIterator i = new BSTIterator(root);
- * while (i.hasNext()) v[f()] = i.next();
+ * Your BSTIterator object will be instantiated and called as such:
+ * BSTIterator obj = new BSTIterator(root);
+ * int param_1 = obj.next();
+ * boolean param_2 = obj.hasNext();
  */
diff --git a/Medium/Divide Two Integers.java b/Medium/Divide Two Integers.java
index 0df8c413..3ecf9dee 100644
--- a/Medium/Divide Two Integers.java	
+++ b/Medium/Divide Two Integers.java	
@@ -1,41 +1,32 @@
 class Solution {
-    public int divide(int dividend, int divisor) {
-        
-        boolean isNeg = false;
-        if ((dividend < 0 && divisor > 0) || (dividend > 0 && divisor < 0)) {
-            isNeg = true;
-        }
-        
-        int ans = 0;
-        
-        long Ldividend = Math.abs((long) dividend);
-        long Ldivisor = Math.abs((long) divisor);
-        
-        if (Ldivisor == 0) return Integer.MAX_VALUE;
-        if (Ldividend == 0 || (Ldividend < Ldivisor)) return 0;
-        
-        long quot = ldivide(Ldividend, Ldivisor);
-        
-        if(quot > Integer.MAX_VALUE) {
-            ans = isNeg == false ? Integer.MAX_VALUE : Integer.MIN_VALUE;
-        }
-        else {
-            ans = (int)(isNeg ? -quot : quot);
-        }
-        
-        return ans;
+  private static int HALF_INT_MIN = -1073741824;
+  public int divide(int dividend, int divisor) {
+    if (dividend == Integer.MIN_VALUE && divisor == -1) {
+      return Integer.MAX_VALUE;
     }
-    
-    private long ldivide(long ldividend, long ldivisor) {
-        if (ldividend < ldivisor) return 0;
-        
-        long sum = ldivisor;
-        long multiple = 1;
-        while ((sum+sum) <= ldividend) {
-            sum += sum;
-            multiple += multiple;
-        }
-
-        return multiple + ldivide(ldividend - sum, ldivisor);
+    int negatives = 2;
+    if (dividend > 0) {
+      negatives--;
+      dividend = -dividend;
     }
+    if (divisor > 0) {
+      negatives--;
+      divisor = -divisor;
+    }
+    int quotient = 0;
+    while (divisor >= dividend) {
+      int powerOfTwo = -1;
+      int value = divisor;
+      while (value >= HALF_INT_MIN && value + value >= dividend) {
+        value += value;
+        powerOfTwo += powerOfTwo;
+      }
+      quotient += powerOfTwo;
+      dividend -= value;
+    }
+    if (negatives != 1) {
+      return -quotient;
+    }
+    return quotient;
+  }
 }
diff --git a/Medium/Is Graph Bipartite.java b/Medium/Is Graph Bipartite.java
index 19c708ea..23f4e0bf 100644
--- a/Medium/Is Graph Bipartite.java	
+++ b/Medium/Is Graph Bipartite.java	
@@ -1,29 +1,27 @@
 class Solution {
-    public boolean isBipartite(int[][] graph) {
-        int[] colors = new int[graph.length];
-        Arrays.fill(colors, -1);
+  public boolean isBipartite(int[][] graph) {
+    int n = graph.length;
+    int[] color = new int[n];
+    Arrays.fill(color, -1);
+    for (int i = 0; i < n; i++) {
+      if (color[i] == -1) {
         Stack<Integer> stack = new Stack<>();
-        
-        for (int i = 0; i < graph.length; i++) {
-            if (colors[i] == -1) {
-                stack.push(i);
-                colors[i] = 0;
-                
-                while (!stack.isEmpty()) {
-                    Integer removed = stack.pop();
-                    for (Integer connect : graph[removed]) {
-                        if (colors[connect] == -1) {
-                            stack.push(connect);
-                            colors[connect] = colors[removed] == 1 ? 0 : 1;
-                        }
-                        else if (colors[connect] == colors[removed]) {
-                            return false;
-                        }
-                    }
-                }
+        stack.push(i);
+        color[i] = 0;
+        while (!stack.isEmpty()) {
+          Integer node = stack.pop();
+          for (Integer neighbor : graph[node]) {
+            if (color[neighbor] == -1) {
+              stack.push(neighbor);
+              color[neighbor] = color[node] ^ 1;
             }
+            else if (color[neighbor] == color[node]) {
+              return false;
+            }
+          }
         }
-        
-        return true;
+      }
     }
+    return true;
+  }
 }
diff --git a/Medium/Most Stones Removed with Same Row or Column.java b/Medium/Most Stones Removed with Same Row or Column.java
new file mode 100644
index 00000000..540efe34
--- /dev/null
+++ b/Medium/Most Stones Removed with Same Row or Column.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int removeStones(int[][] stones) {
+    Set<int[]> visited = new HashSet<>();
+    int numOfIslands = 0;
+    for (int[] stone : stones) {
+      if (!visited.contains(stone)) {
+        dfs(stones, visited, stone);
+        numOfIslands++;
+      }
+    }
+    return stones.length - numOfIslands;
+  }
+  
+  private void dfs(int[][] stones, Set<int[]> visited, int[] stone) {
+    visited.add(stone);
+    for (int[] st : stones) {
+      if ((st[0] == stone[0] || st[1] == stone[1]) && !visited.contains(st)) {
+        dfs(stones, visited, st);
+      }
+    }
+  }
+}

From 96abc5a037f922392a8b627d060fd85540bfdfb1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 12 Aug 2020 11:06:58 -0500
Subject: [PATCH 0267/2175] Added 1 solution & modified 1 solution

---
 Easy/Pascal's Triangle II.java | 27 ++++++++++++++--------
 Medium/Restore IP Address.java | 42 ++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 10 deletions(-)
 create mode 100644 Medium/Restore IP Address.java

diff --git a/Easy/Pascal's Triangle II.java b/Easy/Pascal's Triangle II.java
index 66ec5767..219b923a 100644
--- a/Easy/Pascal's Triangle II.java	
+++ b/Easy/Pascal's Triangle II.java	
@@ -1,14 +1,21 @@
 class Solution {
-    public List<Integer> getRow(int rowIndex) {
-        List<Integer> res = new ArrayList<Integer>();
-        
-        for(int i = 0;i<rowIndex+1;i++) {
-            res.add(1);
-            for(int j=i-1;j>0;j--) {
-                res.set(j, res.get(j-1) + res.get(j));
-            }
+  public List<Integer> getRow(int rowIndex) {
+    int count = 0;
+    List<Integer> list = new ArrayList<>();
+    List<Integer> prev = new ArrayList<>();
+    for (int i = 0; i <= rowIndex; i++) {
+      prev = list;
+      List<Integer> temp = new ArrayList<>();
+      for (int j = 0; j <= i; j++) {
+        if (j == 0 || j == i) {
+          temp.add(1);
         }
-        
-        return res;
+        else {
+          temp.add(prev.get(j - 1) + prev.get(j));
+        }
+      }
+      list = temp;
     }
+    return list;
+  }   
 }
diff --git a/Medium/Restore IP Address.java b/Medium/Restore IP Address.java
new file mode 100644
index 00000000..635e87e4
--- /dev/null
+++ b/Medium/Restore IP Address.java	
@@ -0,0 +1,42 @@
+class Solution {
+  public List<String> restoreIpAddresses(String s) {
+    int n = s.length();
+    LinkedList<String> segments = new LinkedList<String>();
+    List<String> output = new ArrayList<String>();
+    backtrack(s, -1, 3, output, segments, n);
+    return output;
+  }
+  
+  private void backtrack(String s, int prevPos, int dots, List<String> output, LinkedList<String> segments, int n) {
+    int maxPos = Math.min(n - 1, prevPos + 4);
+    for (int i = prevPos + 1; i < maxPos; i++) {
+      String segment = s.substring(prevPos + 1, i + 1);
+      if (isValid(segment)) {
+        segments.add(segment);
+        if (dots - 1 == 0) {
+          updateOutput(s, i, n, segments, output);
+        }
+        else {
+          backtrack(s, i, dots - 1, output, segments, n);
+        }
+        segments.removeLast();
+      }
+    }
+  }
+  
+  public void updateOutput(String s, int currPos, int n, LinkedList<String> segments, List<String> output) {
+    String segment = s.substring(currPos + 1, n);
+    if (isValid(segment)) {
+      segments.add(segment);
+      output.add(String.join(".", segments));
+      segments.removeLast();
+    }
+  }
+
+  public boolean isValid(String segment) {
+    int m = segment.length();
+    if (m > 3)
+      return false;
+    return (segment.charAt(0) != '0') ? (Integer.parseInt(segment) <= 255) : (m == 1);
+  }
+}

From 3557989e1cd0fdf1f4a7bd8b831a4f97f6da7f2b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 13 Aug 2020 07:54:26 -0500
Subject: [PATCH 0268/2175] Added Iterator for Combination.java

---
 Medium/Iterator for Combination.java | 41 ++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Medium/Iterator for Combination.java

diff --git a/Medium/Iterator for Combination.java b/Medium/Iterator for Combination.java
new file mode 100644
index 00000000..3877cc59
--- /dev/null
+++ b/Medium/Iterator for Combination.java	
@@ -0,0 +1,41 @@
+class CombinationIterator {
+  List<String> list;
+  Iterator<String> iter;
+  public CombinationIterator(String characters, int combinationLength) {
+    list = new ArrayList<>();
+    StringBuilder sb = new StringBuilder();
+    helper(characters, sb, 0, combinationLength);
+    iter = list.iterator();
+  }
+  
+  private void helper(String characters, StringBuilder sb, int idx, int combinationLength) {
+    if (sb.length() == combinationLength) {
+      list.add(new String(sb.toString()));
+    }
+    else if (idx == characters.length() || sb.length() > combinationLength) {
+      return;
+    }
+    else {
+      for (int i = idx; i < characters.length(); i++) {
+        sb.append(characters.charAt(i));
+        helper(characters, sb, i + 1, combinationLength);
+        sb.deleteCharAt(sb.length() - 1);
+      }
+    }
+  }
+
+  public String next() {
+    return iter.next();
+  }
+
+  public boolean hasNext() {
+    return iter.hasNext();
+  }
+}
+
+/**
+ * Your CombinationIterator object will be instantiated and called as such:
+ * CombinationIterator obj = new CombinationIterator(characters, combinationLength);
+ * String param_1 = obj.next();
+ * boolean param_2 = obj.hasNext();
+ */

From 163a25a72656677e4edc3ee3185ce0b3e45a4b75 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 14 Aug 2020 10:05:42 -0500
Subject: [PATCH 0269/2175] Modified Longest Palindrome.java

---
 Easy/Longest Palindrome.java | 41 ++++++++++++++----------------------
 1 file changed, 16 insertions(+), 25 deletions(-)

diff --git a/Easy/Longest Palindrome.java b/Easy/Longest Palindrome.java
index c6c3f662..59688ba8 100644
--- a/Easy/Longest Palindrome.java	
+++ b/Easy/Longest Palindrome.java	
@@ -1,28 +1,19 @@
 class Solution {
-    public int longestPalindrome(String s) {
-        int[] count = new int[52];
-        
-        for (int i=0;i<s.length();i++) {
-            int ind = ((int) s.charAt(i));
-            if (ind >= 97) {
-                ind -= 97;
-            }
-            else {
-                ind = ind + 26 - 65;
-            }
-            count[ind]++;
-        }
-        
-        int l = 0;
-        for (int i=0;i<52;i++) {
-            if (count[i]%2 == 0) {
-                l += count[i];
-            }
-            else {
-                l += count[i]-1;
-            }
-        }
-        
-        return s.length() > l ? l+1 : l; 
+  public int longestPalindrome(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      map.put(c, map.getOrDefault(c, 0) + 1);
     }
+    int count = 0;
+    boolean oddTaken = false;
+    for (Character key : map.keySet()) {
+      int val = map.get(key);
+      count += (val / 2) * 2;
+      if ((val == 1 || val % 2 != 0) && !oddTaken) {
+        oddTaken = true;
+        count++;
+      }
+    }
+    return count;
+  }
 }

From ce9e131b4fa0b27cf6d55bc6546ea7f72ed0eb10 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 15 Aug 2020 15:48:34 -0500
Subject: [PATCH 0270/2175] Added 1 solution & modified 1 solution

---
 Medium/Find Permutation.java          | 23 ++++++++++++++
 Medium/Non Overlapping Intervals.java | 46 ++++++++-------------------
 2 files changed, 37 insertions(+), 32 deletions(-)
 create mode 100644 Medium/Find Permutation.java

diff --git a/Medium/Find Permutation.java b/Medium/Find Permutation.java
new file mode 100644
index 00000000..2103c84f
--- /dev/null
+++ b/Medium/Find Permutation.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int[] findPermutation(String s) {
+    int[] ans = new int[s.length() + 1];
+    Stack<Integer> stack = new Stack<>();
+    int idx = 0;
+    for (int i = 1; i <= s.length(); i++) {
+      if (s.charAt(i - 1) == 'I') {
+        stack.push(i);
+        while (!stack.isEmpty()) {
+          ans[idx++] = stack.pop();
+        }
+      }
+      else {
+        stack.push(i);
+      }
+    }
+    stack.push(s.length() + 1);
+    while (!stack.isEmpty()) {
+      ans[idx++] = stack.pop();
+    }
+    return ans;
+  } 
+}
diff --git a/Medium/Non Overlapping Intervals.java b/Medium/Non Overlapping Intervals.java
index 741adddd..cbdae574 100644
--- a/Medium/Non Overlapping Intervals.java	
+++ b/Medium/Non Overlapping Intervals.java	
@@ -1,35 +1,17 @@
-/**
- * Definition for an interval.
- * public class Interval {
- *     int start;
- *     int end;
- *     Interval() { start = 0; end = 0; }
- *     Interval(int s, int e) { start = s; end = e; }
- * }
- */
 class Solution {
-    public static int eraseOverlapIntervals(Interval[] intervals) {
-        if (intervals.length == 0) {
-            return 0;
-        }
-        
-        Arrays.sort(intervals, new Comparator<Interval>() {
-            @Override
-            public int compare(Interval o1, Interval o2) {
-                return o1.end - o2.end;
-            }
-        });
-
-        int count = 1;
-        int end = intervals[0].end;
-
-        for (int i=1; i<intervals.length; i++) {
-            if (intervals[i].start >= end) {
-                end = intervals[i].end;
-                count++;
-            }
-        }
-
-        return intervals.length - count;
+  public int eraseOverlapIntervals(int[][] intervals) {
+    if (intervals.length == 0) {
+      return 0;
     }
+    Arrays.sort(intervals, Comparator.comparingInt(o -> o[1]));
+    int notRemoved = 1;
+    int end = intervals[0][1];
+    for (int i = 1; i < intervals.length; i++) {
+      if (intervals[i][0] >= end) {
+        notRemoved++;
+        end = intervals[i][1];
+      }
+    }
+    return intervals.length - notRemoved;
+  }
 }

From 02befb6bf7ad97d3791db379ea6a1ca7409b1340 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 17 Aug 2020 10:58:20 -0500
Subject: [PATCH 0271/2175] Added 2 solutions

---
 Easy/Three Consecutive Odds.java                   | 10 ++++++++++
 Medium/Minimum Operations to Make Array Equal.java |  5 +++++
 2 files changed, 15 insertions(+)
 create mode 100644 Easy/Three Consecutive Odds.java
 create mode 100644 Medium/Minimum Operations to Make Array Equal.java

diff --git a/Easy/Three Consecutive Odds.java b/Easy/Three Consecutive Odds.java
new file mode 100644
index 00000000..7f2a0064
--- /dev/null
+++ b/Easy/Three Consecutive Odds.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public boolean threeConsecutiveOdds(int[] arr) {
+    for (int i = 2; i < arr.length; i++) {
+      if (arr[i] % 2 != 0 && arr[i - 1] % 2 != 0 && arr[i - 2] % 2 != 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
diff --git a/Medium/Minimum Operations to Make Array Equal.java b/Medium/Minimum Operations to Make Array Equal.java
new file mode 100644
index 00000000..fc570061
--- /dev/null
+++ b/Medium/Minimum Operations to Make Array Equal.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public int minOperations(int n) {
+    return (n / 2) * ((n / 2) + n % 2);
+  }
+}

From 826d5cbd61d1a0c0834343f69a6abce850590f05 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 17 Aug 2020 18:53:28 -0500
Subject: [PATCH 0272/2175] Modified 2 solutions

---
 ...r of Steps to Reduce a Number to Zero.java |  7 +---
 ...rint Immutable Linked List in Reverse.java | 38 ++-----------------
 2 files changed, 4 insertions(+), 41 deletions(-)

diff --git a/Easy/Number of Steps to Reduce a Number to Zero.java b/Easy/Number of Steps to Reduce a Number to Zero.java
index 279fcfee..ddd98ce5 100644
--- a/Easy/Number of Steps to Reduce a Number to Zero.java	
+++ b/Easy/Number of Steps to Reduce a Number to Zero.java	
@@ -2,13 +2,8 @@ class Solution {
   public int numberOfSteps (int num) {
     int count = 0;
     while (num > 0) {
-      if (num % 2 == 0) {
-        num /= 2;
-      }
-      else {
-        num--;
-      }
       count++;
+      num = num % 2 == 0 ? num / 2 : num - 1;
     }
     return count;
   }
diff --git a/Medium/Print Immutable Linked List in Reverse.java b/Medium/Print Immutable Linked List in Reverse.java
index 17a3be68..0ec55d3e 100644
--- a/Medium/Print Immutable Linked List in Reverse.java	
+++ b/Medium/Print Immutable Linked List in Reverse.java	
@@ -8,43 +8,11 @@
  */
 
 class Solution {
-  Stack<ImmutableListNode> stack;
-  ImmutableListNode lastPopped;
   public void printLinkedListInReverse(ImmutableListNode head) {
-    stack = new Stack<>();
-    lastPopped = null;
-    int lengthSquareRoot = (int) Math.log(getLength(head));
-    ImmutableListNode curr = head;
-    int count = 0;
-    while (curr != null) {
-      if (count % lengthSquareRoot == 0) {
-        stack.push(curr);
-      }
-      curr = curr.getNext();
-      count++;
-    }
-    while (!stack.isEmpty()) {
-      ImmutableListNode popped = stack.pop();
-      printNode(popped);
-      lastPopped = popped;
-    }
-  }
-  
-  private void printNode(ImmutableListNode node) {
-    if (node == lastPopped) {
+    if (head == null) {
       return;
     }
-    printNode(node.getNext());
-    node.printValue();
-  }
-  
-  private int getLength(ImmutableListNode node) {
-    int count = 0;
-    while (node != null) {
-      node = node.getNext();
-      count++;
-    }
-    return count;
+    printLinkedListInReverse(head.getNext());
+    head.printValue();
   }
 }
-

From 8e24891da692a05002c0d44f65ece741239b4e3c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 18 Aug 2020 07:35:36 -0500
Subject: [PATCH 0273/2175] Added Numbers With Same Consecutive
 Differences.java

---
 ...ers With Same Consecutive Differences.java | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Numbers With Same Consecutive Differences.java

diff --git a/Medium/Numbers With Same Consecutive Differences.java b/Medium/Numbers With Same Consecutive Differences.java
new file mode 100644
index 00000000..24c35555
--- /dev/null
+++ b/Medium/Numbers With Same Consecutive Differences.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public int[] numsSameConsecDiff(int N, int K) {
+    if (N == 1) {
+      return new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    }
+    Set<Integer> set = new HashSet<>();
+    for (int i = 1; i <= 9; i++) {
+      helper(i, new StringBuilder(), K, set, N);
+    }
+    int[] ans = new int[set.size()];
+    Iterator<Integer> iterator = set.iterator();
+    for (int i = 0; i < ans.length; i++) {
+      ans[i] = iterator.next();
+    }
+    return ans;
+  }
+
+  private void helper(int curr, StringBuilder sb, int k, Set<Integer> set, int n) {
+    if (sb.length() == n) {
+      set.add(Integer.parseInt(sb.toString()));
+    }
+    if (sb.length() > n || curr > 9 || curr < 0) {
+      return;
+    }
+    else {
+      sb.append(curr);
+      helper(curr + k, sb, k, set, n);
+      helper(curr - k, sb, k, set, n);
+      sb.deleteCharAt(sb.length() - 1);
+    }
+  }
+}

From 0b0d5032ff611a261c427c7f030c56f262f5f632 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 18 Aug 2020 08:39:35 -0500
Subject: [PATCH 0274/2175] Added Maximum Number of Occurrences of a
 Substring.java

---
 ... Number of Occurrences of a Substring.java | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Maximum Number of Occurrences of a Substring.java

diff --git a/Medium/Maximum Number of Occurrences of a Substring.java b/Medium/Maximum Number of Occurrences of a Substring.java
new file mode 100644
index 00000000..6d957c4f
--- /dev/null
+++ b/Medium/Maximum Number of Occurrences of a Substring.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public int maxFreq(String s, int maxLetters, int minSize, int maxSize) {
+    int n = s.length();
+    if (minSize > n) {
+      return 0;
+    }
+    Map<String, Integer> substringMap = new HashMap<>();
+    for (int i = 0; i < n; i++) {
+      Map<Character, Integer> charMap = new HashMap<>();
+      for (int j = 0; j < maxSize; j++) {
+        if (i + j >= n) {
+          break;
+        }       
+        charMap.put(s.charAt(i + j), charMap.getOrDefault(s.charAt(i + j), 0) + 1);
+        if (charMap.size() > maxLetters) {
+          break;
+        }
+        if (j >= minSize - 1) {
+          substringMap.put(
+            s.substring(i, i + j + 1), substringMap.getOrDefault(s.substring(i, i + j + 1), 0) + 1
+          );
+        }
+      }
+    }
+    int maxFreqCount = 0;
+    for (String substr : substringMap.keySet()) {
+      maxFreqCount = Math.max(maxFreqCount, substringMap.get(substr));
+    }
+    return maxFreqCount;
+  }
+}

From 2b6d4f9f5869b97993fa594e68cd8957f49dd879 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 19 Aug 2020 09:31:07 -0500
Subject: [PATCH 0275/2175] Modified Goat Latin.java

---
 Easy/Goat Latin.java | 44 +++++++++++++++++---------------------------
 1 file changed, 17 insertions(+), 27 deletions(-)

diff --git a/Easy/Goat Latin.java b/Easy/Goat Latin.java
index 28b6b950..56c98048 100644
--- a/Easy/Goat Latin.java	
+++ b/Easy/Goat Latin.java	
@@ -1,38 +1,28 @@
 class Solution {
   public String toGoatLatin(String S) {
     StringBuilder sb = new StringBuilder();
-    StringBuilder temp = new StringBuilder();
-    String vowels = "aeiouAEIOU";
-    StringBuilder aAppend = new StringBuilder("a");
-    int idx = 0;
+    StringBuilder endAppend = new StringBuilder("a");
+    final String CONSTANT_APPEND = "ma";
+    int start = 0;
+    int end = 0;
     int n = S.length();
-    Boolean startVowel = null;
-    while (idx < n) {
-      if (startVowel == null) {
-        startVowel = vowels.indexOf(S.charAt(idx)) != -1;
+    while (end < n) {
+      while (end < n && S.charAt(end) != ' ') {
+        end++;
       }
-      if (S.charAt(idx) == ' ' || idx == n - 1) {
-        if (S.charAt(idx) != ' ') {
-          temp.append(S.charAt(idx));
-        }
-        if (!startVowel) {
-          char c = temp.charAt(0);
-          temp.deleteCharAt(0);
-          temp.append(c);
-        }
-        temp.append("ma").append(aAppend.toString());
-        sb.append(temp.toString());
-        temp.setLength(0);
-        aAppend.append("a");
-        startVowel = null;
-        if (idx != n - 1) {
-          sb.append(" ");
-        }
+      char c = Character.toLowerCase(S.charAt(start));
+      if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
+        sb.append(S.substring(start, end)).append(CONSTANT_APPEND).append(endAppend.toString());
       }
       else {
-        temp.append(S.charAt(idx));
+        sb.append(S.substring(start + 1, end)).append(S.charAt(start)).append(CONSTANT_APPEND).append(endAppend.toString());
+      }
+      endAppend.append('a');
+      end++;
+      start = end;
+      if (end < n) {
+        sb.append(' ');
       }
-      idx++;
     }
     return sb.toString();
   }

From 69c9ed642ce9d2406fdbafa2172e6314b43c9cff Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 19 Aug 2020 13:15:03 -0500
Subject: [PATCH 0276/2175] Added 2 solutions & modified 1 solution

---
 Easy/Count Good Triplets.java         | 20 ++++++++++++++++++++
 Easy/Number of Days in a Month.java   | 27 +++++----------------------
 Easy/String Matching in an Array.java | 26 ++++++++++++++++++++++++++
 3 files changed, 51 insertions(+), 22 deletions(-)
 create mode 100644 Easy/Count Good Triplets.java
 create mode 100644 Easy/String Matching in an Array.java

diff --git a/Easy/Count Good Triplets.java b/Easy/Count Good Triplets.java
new file mode 100644
index 00000000..d903c472
--- /dev/null
+++ b/Easy/Count Good Triplets.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int countGoodTriplets(int[] arr, int a, int b, int c) {
+    int count = 0;
+    int n = arr.length;
+    for (int i = 0; i < n; i++) {
+      for (int j = i + 1; j < n; j++) {
+        for (int k = j + 1; k < n; k++) {
+          if (
+            Math.abs(arr[i] - arr[j]) <= a && 
+            Math.abs(arr[j] - arr[k]) <= b && 
+            Math.abs(arr[k] - arr[i]) <= c
+          ) {
+            count++;  
+          }
+        }
+      }
+    }
+    return count;
+  }
+}
diff --git a/Easy/Number of Days in a Month.java b/Easy/Number of Days in a Month.java
index 5ef06149..d2268cc8 100644
--- a/Easy/Number of Days in a Month.java	
+++ b/Easy/Number of Days in a Month.java	
@@ -1,24 +1,7 @@
 class Solution {
-    public int numberOfDays(int Y, int M) {
-        int[] arr = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-        if (M == 2) {
-            return isLeapYear(Y) ? arr[M - 1] + 1 : arr[M - 1];
-        }
-
-        return arr[M- 1];
-    }
-
-    private boolean isLeapYear (int y) {
-        if (y % 4  == 0) {
-            if (y % 100 == 0) {
-                return y % 400 == 0;
-            }
-            else {
-                return true;
-            }
-        }
-        else {
-            return false;
-        }
-    }
+  final int[] DAY_COUNT = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+  public int numberOfDays(int Y, int M) {
+    boolean isLeapYear = Y % 4 == 0 && ((Y % 100 == 0) ? (Y % 400 == 0) : true);
+    return DAY_COUNT[M - 1] + (M == 2 ? (isLeapYear ? 1 : 0) : 0);
+  }
 }
diff --git a/Easy/String Matching in an Array.java b/Easy/String Matching in an Array.java
new file mode 100644
index 00000000..463f98b1
--- /dev/null
+++ b/Easy/String Matching in an Array.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public List<String> stringMatching(String[] words) {
+    List<String> list = new ArrayList<>();
+    for (int i = 0; i < words.length; i++) {
+      for (int j = 0; j < words.length; j++) {
+        if (i != j && isSubstring(words[i], words[j])) {
+          list.add(words[i]);
+          break;
+        }
+      }
+    }
+    return list;
+  }
+  
+  private boolean isSubstring(String s1, String s2) {
+    if (s1.length() > s2.length()) {
+      return false;
+    }
+    for (int i = 0; i < s2.length() - s1.length() + 1; i++) {
+      if (s2.substring(i, i + s1.length()).equals(s1)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

From 23bb89c3123effb9dab6e913742e5218b2c7d218 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 20 Aug 2020 09:00:05 -0500
Subject: [PATCH 0277/2175] Added Meeting Scheduler.java

---
 Medium/Meeting Scheduler.java | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Meeting Scheduler.java

diff --git a/Medium/Meeting Scheduler.java b/Medium/Meeting Scheduler.java
new file mode 100644
index 00000000..42f7b044
--- /dev/null
+++ b/Medium/Meeting Scheduler.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public List<Integer> minAvailableDuration(int[][] slots1, int[][] slots2, int duration) {
+    int idx1 = 0;
+    int idx2 = 0;
+    Arrays.sort(slots1, new sortByStartAndEndTime());
+    Arrays.sort(slots2, new sortByStartAndEndTime());
+    while (idx1 < slots1.length && idx2 < slots2.length) {
+      int maxStart = Math.max(slots1[idx1][0], slots2[idx2][0]);
+      int minEnd = Math.min(slots1[idx1][1], slots2[idx2][1]);
+      if (minEnd - maxStart >= duration) {
+        return Arrays.asList(maxStart, maxStart + duration);
+      }
+      if (slots1[idx1][1] < slots2[idx2][1]) {
+        idx1++;
+      }
+      else {
+        idx2++;
+      }
+    }
+    return new ArrayList<>();
+  }
+
+  class sortByStartAndEndTime implements Comparator<int[]> {
+
+    @Override
+    public int compare(int[] o1, int[] o2) {
+      int c = o1[0] - o2[0];
+      if (c != 0) {
+        return c;
+      }
+      return o1[1] - o2[1];
+    }
+  }
+}

From af2906cad506a925e0a4614379aeb4abd5b512ec Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 20 Aug 2020 09:06:16 -0500
Subject: [PATCH 0278/2175] Update README.md

---
 README.md | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 1c006c04..41ee21a2 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,6 @@
 # Leetcode-Java-Solutions 
 
 ## Solutions to Leetcode problems in Java
-Category | Count
---- | ---
-[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy) | 282
-[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium) | 331
-[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard) | 54
+
+## [Current Leetcode profile: Solved 700+ Problems](https://leetcode.com/varunsjsu/)
+## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)

From 212347d005b29ec0535de5d9a87110a8856a5ba8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 20 Aug 2020 10:29:46 -0500
Subject: [PATCH 0279/2175] Added Remove Covered Intervals.java

---
 Medium/Remove Covered Intervals.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Remove Covered Intervals.java

diff --git a/Medium/Remove Covered Intervals.java b/Medium/Remove Covered Intervals.java
new file mode 100644
index 00000000..edb33e1d
--- /dev/null
+++ b/Medium/Remove Covered Intervals.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int removeCoveredIntervals(int[][] intervals) {
+    Arrays.sort(intervals, new Comparator<int[]>(){
+      public int compare(int[] i1, int[] i2) {
+        int c = i2[1] - i1[1];
+        if (c != 0) {
+          return c;
+        }
+        return i1[0] - i2[0];
+      }
+    });
+    int idx = 0;
+    int count = 0;
+    while (idx < intervals.length) {
+      int[] currInterval = intervals[idx];
+      idx++;
+      while (idx < intervals.length && intervals[idx][0] >= currInterval[0] && intervals[idx][1] <= currInterval[1]
+      ) {
+        count++;
+        idx++;
+      }
+    }
+    return intervals.length - count;
+  }
+}

From 01ec6cc3a9fc0e9dfe6c630072db0530a4169a7a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 21 Aug 2020 10:45:05 -0500
Subject: [PATCH 0280/2175] Added 2 solutions

---
 ... Number of Non-Overlapping Substrings.java | 38 +++++++++++++++++++
 Medium/Minimum Knight Moves.java              | 38 +++++++++++++++++++
 2 files changed, 76 insertions(+)
 create mode 100644 Hard/Maximum Number of Non-Overlapping Substrings.java
 create mode 100644 Medium/Minimum Knight Moves.java

diff --git a/Hard/Maximum Number of Non-Overlapping Substrings.java b/Hard/Maximum Number of Non-Overlapping Substrings.java
new file mode 100644
index 00000000..419ec9ce
--- /dev/null
+++ b/Hard/Maximum Number of Non-Overlapping Substrings.java	
@@ -0,0 +1,38 @@
+class Solution {
+  public List<String> maxNumOfSubstrings(String s) {
+    int[] leftIdx = new int[26];
+    int[] rightIdx = new int[26];
+    Arrays.fill(leftIdx, s.length());
+    List<String> ans = new ArrayList<>();
+    for (int i = 0; i < s.length(); i++) {
+      int c = s.charAt(i) - 'a';
+      leftIdx[c] = Math.min(i, leftIdx[c]);
+      rightIdx[c] = i;
+    }
+    int right = -1;
+    for (int i = 0; i < s.length(); i++) {
+      if (i == leftIdx[s.charAt(i) - 'a']) {
+        int newRight = helper(s, i, leftIdx, rightIdx);
+        if (newRight != -1) {
+          if (i > right) {
+            ans.add("");
+          }
+          right = newRight;
+          ans.set(ans.size() - 1, s.substring(i, right + 1));
+        }
+      }
+    }
+    return ans;
+  }
+  
+  private int helper(String s, int idx, int[] leftIdx, int[] rightIdx) {
+    int right = rightIdx[s.charAt(idx) - 'a'];
+    for (int i = idx; i <= right; i++) {
+      if (leftIdx[s.charAt(i) - 'a'] < idx) {
+        return -1;
+      }
+      right = Math.max(right, rightIdx[s.charAt(i) - 'a']);
+    }
+    return right;
+  }
+}
diff --git a/Medium/Minimum Knight Moves.java b/Medium/Minimum Knight Moves.java
new file mode 100644
index 00000000..94d27fbe
--- /dev/null
+++ b/Medium/Minimum Knight Moves.java	
@@ -0,0 +1,38 @@
+class Solution {
+  public final int[][] DIRS = {{2, 1}, {1, 2}, {-1, 2}, {-2, 1}, {-2, -1}, {-1, -2}, {1, -2}, {2, -1}};
+  public int minKnightMoves(int x, int y) {
+    int currX = 0;
+    int currY = 0;
+    int targetX = Math.abs(x);
+    int targetY = Math.abs(y);
+    Set<String> visited = new HashSet<>();
+    Queue<int[]> queue = new LinkedList<>();
+    int numOfSteps = 0;
+    visited.add(currX + "|" + currY);
+    queue.add(new int[]{currX, currY});
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      boolean found = false;
+      while (size-- > 0) {
+        int[] removed = queue.remove();
+        if (removed[0] == targetX && removed[1] == targetY) {
+          found = true;
+          break;
+        }
+        for (int[] dir : DIRS) {
+          int newX = removed[0] + dir[0];
+          int newY = removed[1] + dir[1];
+          if (!visited.contains(newX + "|" + newY) && newX >= -1 && newY >= -1) {
+            visited.add(newX + "|" + newY);
+            queue.add(new int[]{newX, newY});
+          }
+        }
+      }
+      if (found) {
+        break;
+      }
+      numOfSteps++;
+    }
+    return numOfSteps;
+  }
+}

From e496c539364d0bf77a487a1b0d5eef6962a96516 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 21 Aug 2020 17:27:45 -0500
Subject: [PATCH 0281/2175] Added 1 solution & modified 3 solutions

---
 Easy/Buddy Strings.java                       | 61 ++++++++++++-------
 Easy/N-th Tribonacci Number.java              | 35 +++++------
 Easy/Valid Word Abbrevation.java              | 49 +++++++--------
 ...a Binary Tree in a Clone of That Tree.java | 22 +++++++
 4 files changed, 98 insertions(+), 69 deletions(-)
 create mode 100644 Medium/Find a Corresponding Node of a Binary Tree in a Clone of That Tree.java

diff --git a/Easy/Buddy Strings.java b/Easy/Buddy Strings.java
index a4d76364..c6cdc61a 100644
--- a/Easy/Buddy Strings.java	
+++ b/Easy/Buddy Strings.java	
@@ -1,25 +1,44 @@
 class Solution {
-	public static boolean buddyStrings(String A, String B) {
-	    if (A.length() != B.length() || A.length() <= 1 || B.length() <= 1) {
-	        return false;
-	    }
-        
-        if (A.equals(B)) {
-            Set<Character> s = new HashSet<Character>();
-            for (char c : A.toCharArray()) {
-                s.add(c);
-            }
-            
-            return s.size() < A.length();
+  public boolean buddyStrings(String A, String B) {
+    if (A.length() != B.length()) {
+      return false;
+    }
+    char requiredChar = '-';
+    char mismatchChar = '-';
+    int[] counter = new int[26];
+    for (int i = 0; i < A.length(); i++) {
+      if (A.charAt(i) != B.charAt(i)) {
+	      // Already done one swap hence cannot do any more swaps
+        if (requiredChar == '_') {
+          return false;
         }
-        
-        List<Integer> dif = new ArrayList<>();
-        for (int i = 0; i < A.length(); ++i) {
-            if (A.charAt(i) != B.charAt(i)) {
-                dif.add(i);
-            }
+        if (requiredChar == '-') {
+          requiredChar = B.charAt(i);
+          mismatchChar = A.charAt(i);
         }
-        
-        return dif.size() == 2 && A.charAt(dif.get(0)) == B.charAt(dif.get(1)) && A.charAt(dif.get(1)) == B.charAt(dif.get(0)); 
-	}
+        else {
+		      // Check if swap is possible from previous mismatch
+          if (B.charAt(i) == mismatchChar && A.charAt(i) == requiredChar) {
+            requiredChar = '_';
+          }
+          else {
+            return false;
+          }
+        }
+      }
+      else {
+        counter[A.charAt(i) - 'a']++;
+      }
+    }
+    if (mismatchChar != '-') {
+      return requiredChar == '_';
+    }
+    // Check if we have more than 1 occurrence of same characters. We can swap them to fulfil the condition
+    for (int i = 0; i < 26; i++) {
+      if (counter[i] > 1) {
+        return true;
+      }
+    }
+    return false;
+  }
 }
diff --git a/Easy/N-th Tribonacci Number.java b/Easy/N-th Tribonacci Number.java
index ebb955b4..cfaaeca9 100644
--- a/Easy/N-th Tribonacci Number.java	
+++ b/Easy/N-th Tribonacci Number.java	
@@ -1,24 +1,17 @@
 class Solution {
-    Integer[] memo;
-    public int tribonacci(int n) {
-        memo = new Integer[n + 1];
-        return helper(n);
-    }
-
-    private int helper(int n) {
-        if (n == 0) {
-            return 0;
-        }
-
-        if (n == 1 || n == 2) {
-            return 1;
-        }
-
-        if (memo[n] != null) {
-            return memo[n];
-        }
-
-        memo[n] = helper(n - 3) + helper(n - 2) + helper(n - 1);
-        return memo[n];
+  public int tribonacci(int n) {
+    int[] dp = new int[Math.max(n + 1, 3)];
+    dp[0] = 0;
+    dp[1] = 1;
+    dp[2] = 1;
+    return helper(n, dp);
+  }
+  
+  private int helper(int n, int[] dp) {
+    if (n == 0 || dp[n] != 0) {
+      return dp[n];
     }
+    dp[n] = helper(n - 1, dp) + helper(n - 2, dp) + helper(n - 3, dp);
+    return dp[n];
+  }
 }
diff --git a/Easy/Valid Word Abbrevation.java b/Easy/Valid Word Abbrevation.java
index b067c570..4299405e 100644
--- a/Easy/Valid Word Abbrevation.java	
+++ b/Easy/Valid Word Abbrevation.java	
@@ -1,31 +1,26 @@
 class Solution {
-    public static boolean validWordAbbreviation(String word, String abbr) {
-        char[] wordChar = word.toCharArray();
-        char[] abbrChar = abbr.toCharArray();
-
-        int i = 0;
-        int j = 0;
-
-        while (j < abbrChar.length && i < wordChar.length) {
-            if (abbrChar[j] == wordChar[i]) {
-                i++;
-                j++;
-                continue;
-            }
-
-            if (abbrChar[j] <= '0' || abbrChar[j] > '9') {
-                return false;
-            }
-
-            int start = j;
-            while (j<abbrChar.length && abbrChar[j] >= '0' && abbrChar[j] <= '9') {
-                ++j;
-            }
-
-            int num = Integer.valueOf(abbr.substring(start, j));
-            i += num;
+  public boolean validWordAbbreviation(String word, String abbr) {
+    int idx1 = 0;
+    int idx2 = 0;
+    while (idx1 < word.length() && idx2 < abbr.length()) {
+      if (!Character.isDigit(abbr.charAt(idx2))) {
+        if (word.charAt(idx1) != abbr.charAt(idx2)) {
+          return false;
         }
-
-        return i == wordChar.length && j == abbrChar.length;
+        idx1++;
+        idx2++;
+      }
+      else {
+        if (abbr.charAt(idx2) == '0') {
+          return false;
+        }
+        int count = 0;
+        while (idx2 < abbr.length() && Character.isDigit(abbr.charAt(idx2))) {
+          count = count * 10 + Character.getNumericValue(abbr.charAt(idx2++));
+        }
+        idx1 += count;
+      }
     }
+    return idx1 == word.length() && idx2 == abbr.length();
+  }
 }
diff --git a/Medium/Find a Corresponding Node of a Binary Tree in a Clone of That Tree.java b/Medium/Find a Corresponding Node of a Binary Tree in a Clone of That Tree.java
new file mode 100644
index 00000000..6be836db
--- /dev/null
+++ b/Medium/Find a Corresponding Node of a Binary Tree in a Clone of That Tree.java	
@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+
+class Solution {
+  public final TreeNode getTargetCopy(final TreeNode original, final TreeNode cloned, final TreeNode target) {
+    if (original == null || original == target) {
+      return cloned;
+    }
+    TreeNode leftResult = getTargetCopy(original.left, cloned.left, target);
+    if (leftResult != null) {
+      return leftResult;
+    }
+    return getTargetCopy(original.right, cloned.right, target);
+  }
+}

From 52e82b906656fa96444c60ed7b1cf9b39d2b8db3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 22 Aug 2020 17:52:11 -0500
Subject: [PATCH 0282/2175] Added 2 solutions

---
 Easy/Thousand Separator.java                  | 20 +++++++++++++++++++
 ...Number of Vertices to Reach All Nodes.java | 15 ++++++++++++++
 2 files changed, 35 insertions(+)
 create mode 100644 Easy/Thousand Separator.java
 create mode 100644 Medium/Minimum Number of Vertices to Reach All Nodes.java

diff --git a/Easy/Thousand Separator.java b/Easy/Thousand Separator.java
new file mode 100644
index 00000000..a156c77e
--- /dev/null
+++ b/Easy/Thousand Separator.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public String thousandSeparator(int n) {
+    if (n == 0) {
+      return "0";
+    }
+    StringBuilder sb = new StringBuilder();
+    int count = 0;
+    while (n > 0) {
+      int rem = n % 10;
+      sb.append(rem);
+      count++;
+      n /= 10;
+      if (count == 3 && n > 0) {
+        sb.append('.');
+        count = 0;
+      }
+    }
+    return sb.reverse().toString();
+  }
+}
diff --git a/Medium/Minimum Number of Vertices to Reach All Nodes.java b/Medium/Minimum Number of Vertices to Reach All Nodes.java
new file mode 100644
index 00000000..6c0688b6
--- /dev/null
+++ b/Medium/Minimum Number of Vertices to Reach All Nodes.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
+    int[] indegree = new int[n];
+    for (List<Integer> edge : edges) {
+      indegree[edge.get(1)]++;
+    }
+    List<Integer> ans = new ArrayList<>();
+    for (int i = 0; i < n; i++) {
+      if (indegree[i] == 0) {
+        ans.add(i);
+      }
+    }
+    return ans;
+  }
+}

From 43ada5a2a656c6c2cf9916ff38920687df614803 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 22 Aug 2020 18:54:08 -0500
Subject: [PATCH 0283/2175] Added Minimum Add to Make Parentheses Valid.java

---
 ...Minimum Add to Make Parentheses Valid.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Minimum Add to Make Parentheses Valid.java

diff --git a/Medium/Minimum Add to Make Parentheses Valid.java b/Medium/Minimum Add to Make Parentheses Valid.java
new file mode 100644
index 00000000..bc78b451
--- /dev/null
+++ b/Medium/Minimum Add to Make Parentheses Valid.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int minAddToMakeValid(String S) {
+    int count = 0;
+    int open = 0;
+    for (char c : S.toCharArray()) {
+      if (c == '(') {
+        open++;
+      }
+      else {
+        if (open != 0) {
+          open--;
+        }
+        else {
+          count++;
+        }
+      }
+    }
+    return count + open;
+  }
+}

From 593f768479f9c24c8b5cffe313e8a016b1194adc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 23 Aug 2020 11:52:27 -0500
Subject: [PATCH 0284/2175] Added 1 solution & modified 1 solution

---
 ...st Visited Sector in a Circular Track.java | 21 ++++++++++++++
 Hard/Stream of Characters.java                | 29 +++++++++----------
 2 files changed, 34 insertions(+), 16 deletions(-)
 create mode 100644 Easy/Most Visited Sector in a Circular Track.java

diff --git a/Easy/Most Visited Sector in a Circular Track.java b/Easy/Most Visited Sector in a Circular Track.java
new file mode 100644
index 00000000..012b1c2b
--- /dev/null
+++ b/Easy/Most Visited Sector in a Circular Track.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public List<Integer> mostVisited(int n, int[] rounds) {
+    List<Integer> list = new ArrayList<>();
+    int from = rounds[0];
+    int to = rounds[rounds.length - 1];
+    if (to >= from) {
+      for (int i = from; i <= to; i++) {
+        list.add(i);
+      }
+    }
+    else {
+      for (int i = 1; i <= n; i++) {
+        if (i == to + 1) {
+          i = from;
+        }
+        list.add(i);
+      }
+    }
+    return list;
+  }
+}
diff --git a/Hard/Stream of Characters.java b/Hard/Stream of Characters.java
index 010be550..02fe377a 100644
--- a/Hard/Stream of Characters.java	
+++ b/Hard/Stream of Characters.java	
@@ -5,19 +5,15 @@ public StreamChecker(String[] words) {
     root = new TrieNode('-');
     stream = new ArrayDeque();
     for (String word : words) {
-      addWord(word);
-    }
-  }
-  
-  private void addWord(String s) {
-    TrieNode curr = root;
-    for (int i = s.length() - 1; i >= 0; i--) {
-      if (!curr.map.containsKey(s.charAt(i))) {
-        curr.map.put(s.charAt(i), new TrieNode(s.charAt(i)));
+      TrieNode curr = root;
+      for (int i = word.length() - 1; i >= 0; i--) {
+        if (!curr.map.containsKey(word.charAt(i))) {
+          curr.map.put(word.charAt(i), new TrieNode(word.charAt(i)));
+        }
+        curr = curr.map.get(word.charAt(i));
       }
-      curr = curr.map.get(s.charAt(i));
+      curr.isWord = true;
     }
-    curr.isWord = true;
   }
 
   public boolean query(char letter) {
@@ -36,11 +32,6 @@ public boolean query(char letter) {
   }
 }
 
-/**
- * Your StreamChecker object will be instantiated and called as such:
- * StreamChecker obj = new StreamChecker(words);
- * boolean param_1 = obj.query(letter);
- */
 
 class TrieNode {
   char c;
@@ -53,3 +44,9 @@ public TrieNode(char c) {
     isWord = false;
   }
 }
+
+/**
+ * Your StreamChecker object will be instantiated and called as such:
+ * StreamChecker obj = new StreamChecker(words);
+ * boolean param_1 = obj.query(letter);
+ */

From cd1d4786ab3acc185baf19780e3dbb85aef8e8d6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 24 Aug 2020 09:50:08 -0500
Subject: [PATCH 0285/2175] Added 2 solutions & modified 1 solution

---
 Easy/Sum of left leaves.java                  | 33 +++++++++--------
 ... All Adjacent Duplicates in String II.java | 36 +++++++++++++++++++
 ...emove Sub-Folders from the Filesystem.java | 24 +++++++++++++
 3 files changed, 79 insertions(+), 14 deletions(-)
 create mode 100644 Medium/Remove All Adjacent Duplicates in String II.java
 create mode 100644 Medium/Remove Sub-Folders from the Filesystem.java

diff --git a/Easy/Sum of left leaves.java b/Easy/Sum of left leaves.java
index 96ebf76b..7197aa1c 100644
--- a/Easy/Sum of left leaves.java	
+++ b/Easy/Sum of left leaves.java	
@@ -15,23 +15,28 @@
  */
 class Solution {
   public int sumOfLeftLeaves(TreeNode root) {
-    int[] sum = {0};
-    helper(root, null, sum);
-    return sum[0];
-  } 
-  
-  private void helper(TreeNode root, TreeNode parent, int[] sum) {
     if (root == null) {
-      return;
+      return 0;
     }
-    if (root.left == null && root.right == null) {
-      if (parent != null && parent.left == root) {
-        sum[0] += root.val;
+    int sum = 0;
+    Queue<TreeNode[]> queue = new LinkedList<>();
+    queue.add(new TreeNode[]{root, null});
+    while (!queue.isEmpty()) {
+      TreeNode[] removed = queue.remove();
+      if (removed[0].left == null && removed[0].right == null) {
+        if (removed[1] != null && removed[1].left == removed[0]) {
+          sum += removed[0].val;
+        }
+      }
+      else {
+        if (removed[0].left != null) {
+          queue.add(new TreeNode[]{removed[0].left, removed[0]});
+        }
+        if (removed[0].right != null) {
+          queue.add(new TreeNode[]{removed[0].right, removed[0]});
+        }
       }
     }
-    else {
-      helper(root.left, root, sum);
-      helper(root.right, root, sum);
-    }
+    return sum;
   }
 }
diff --git a/Medium/Remove All Adjacent Duplicates in String II.java b/Medium/Remove All Adjacent Duplicates in String II.java
new file mode 100644
index 00000000..f727a688
--- /dev/null
+++ b/Medium/Remove All Adjacent Duplicates in String II.java	
@@ -0,0 +1,36 @@
+class Solution {
+  public String removeDuplicates(String s, int k) {
+    Stack<Pair> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
+      if (!stack.isEmpty() && stack.peek().ch == c) {
+        stack.peek().val++;
+      }
+      else {
+        stack.push(new Pair(c, 1));
+      }
+      if (stack.peek().val == k) {
+        stack.pop();
+      }
+    }
+    StringBuilder sb = new StringBuilder();
+    while (!stack.isEmpty()) {
+      Pair removed = stack.pop();
+      int count = removed.val;
+      while (count-- > 0) {
+        sb.append(removed.ch);
+      }
+    }
+    return sb.reverse().toString();
+  }
+}
+
+
+class Pair {
+  char ch;
+  int val;
+  
+  public Pair(char ch, int val) {
+    this.ch = ch;
+    this.val = val;
+  }
+}
diff --git a/Medium/Remove Sub-Folders from the Filesystem.java b/Medium/Remove Sub-Folders from the Filesystem.java
new file mode 100644
index 00000000..2d91c97e
--- /dev/null
+++ b/Medium/Remove Sub-Folders from the Filesystem.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public List<String> removeSubfolders(String[] folder) {
+    Set<String> set = new HashSet<>();
+    Arrays.sort(folder, new Comparator<String>(){
+      public int compare(String s1, String s2) {
+        return s1.length() - s2.length();
+      }
+    });
+    for (String fl : folder) {
+      String[] files = fl.split("/");
+      StringBuilder sb = new StringBuilder();
+      for (int i = 1; i < files.length; i++) {
+        sb.append("/").append(files[i]);
+        if (set.contains(sb.toString())) {
+          break;
+        }
+      }
+      if (sb.length() > 0) {
+        set.add(sb.toString());
+      }
+    }
+    return new ArrayList<>(set);
+  }
+}

From d497e738da06ba0c968247a0e24556fcb3ad1f67 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 26 Aug 2020 07:16:26 -0500
Subject: [PATCH 0286/2175] Modified Fizz Buzz.java

---
 Easy/Fizz Buzz.java | 11 +++++++++++
 Easy/FizzBuzz.java  | 11 -----------
 2 files changed, 11 insertions(+), 11 deletions(-)
 create mode 100644 Easy/Fizz Buzz.java
 delete mode 100644 Easy/FizzBuzz.java

diff --git a/Easy/Fizz Buzz.java b/Easy/Fizz Buzz.java
new file mode 100644
index 00000000..73fa230f
--- /dev/null
+++ b/Easy/Fizz Buzz.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public List<String> fizzBuzz(int n) {
+    return IntStream.range(1, n + 1)
+        .boxed()
+        .map(e -> (
+                e % 3 == 0 && e % 5 == 0 ? "FizzBuzz"
+                    : (e % 3 == 0 ? "Fizz" : (e % 5 == 0 ? "Buzz" : String.valueOf(e)))
+            )
+        ).collect(Collectors.toList());
+  }
+}
diff --git a/Easy/FizzBuzz.java b/Easy/FizzBuzz.java
deleted file mode 100644
index 7af5e630..00000000
--- a/Easy/FizzBuzz.java
+++ /dev/null
@@ -1,11 +0,0 @@
-class Solution {
-    public List<String> fizzBuzz(int n) {
-        List<String> list = new ArrayList<>();
-        
-        for (int i=1; i <= n; i++) {
-            list.add((i%3 != 0 && i % 5 != 0) ? String.valueOf(i) : (i % 3 == 0 ? "Fizz" : "") + (i % 5 == 0 ? "Buzz" : ""));
-        }
-
-        return list;
-    }
-}

From 38c6fa2c6ca6f914b79c6f31e73b53f6b6af83a8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 27 Aug 2020 16:11:34 -0500
Subject: [PATCH 0287/2175] Modified Find Right Interval.java

---
 Medium/Find Right Interval.java | 55 ++++++++++-----------------------
 1 file changed, 16 insertions(+), 39 deletions(-)

diff --git a/Medium/Find Right Interval.java b/Medium/Find Right Interval.java
index 89769585..2932d5e8 100644
--- a/Medium/Find Right Interval.java	
+++ b/Medium/Find Right Interval.java	
@@ -1,42 +1,19 @@
-/**
- * Definition for an interval.
- * public class Interval {
- *     int start;
- *     int end;
- *     Interval() { start = 0; end = 0; }
- *     Interval(int s, int e) { start = s; end = e; }
- * }
- */
 class Solution {
-    public int[] findRightInterval(Interval[] intervals) {
-        int n = intervals.length;
-        if (n == 1) {
-            return new int[]{-1};
-        }
-
-        int[] start = new int[n];
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int i=0; i<intervals.length; i++) {
-            start[i] = intervals[i].start;
-            map.put(intervals[i].start, i);
-        }
-
-        Arrays.sort(start);
-        int[] ans = new int[intervals.length];
-        for (int i=0; i<n; i++) {
-            int end = intervals[i].end;
-            int x = Arrays.binarySearch(start, end);
-            if (x > 0) {
-                ans[i] = map.get(end);
-            }
-            else if (-x > n) {
-                ans[i] = -1;
-            }
-            else {
-                ans[i] = map.get(start[-x-1]);
-            }
-        }
-
-        return ans;
+  public int[] findRightInterval(int[][] intervals) {
+    TreeMap<Integer, PriorityQueue<Integer>> map = new TreeMap<>();
+    for (int i = 0; i < intervals.length; i++) {
+      map.computeIfAbsent(intervals[i][0], k -> new PriorityQueue<>(
+          Comparator.comparingInt(o -> intervals[o][0]))
+      ).add(i);
     }
+    int[] ans = new int[intervals.length];
+    Arrays.fill(ans, -1);
+    for (int i = 0; i < intervals.length; i++) {
+      Integer upper = map.ceilingKey(intervals[i][1]);
+      if (upper != null) {
+        ans[i] = map.get(upper).peek();
+      }
+    }
+    return ans;
+  }
 }

From 796a99d8f82f006546fca6efc86a3c19fa1981fc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 28 Aug 2020 09:23:11 -0500
Subject: [PATCH 0288/2175] Added 1 solution & modified 1 solution

---
 Medium/Implement Rand10() Using Rand7().java  | 19 ++++++------
 ... Longest Repeated Character Substring.java | 29 +++++++++++++++++++
 2 files changed, 38 insertions(+), 10 deletions(-)
 create mode 100644 Medium/Swap For Longest Repeated Character Substring.java

diff --git a/Medium/Implement Rand10() Using Rand7().java b/Medium/Implement Rand10() Using Rand7().java
index 8e1d9cc1..4feb5a1f 100644
--- a/Medium/Implement Rand10() Using Rand7().java	
+++ b/Medium/Implement Rand10() Using Rand7().java	
@@ -4,15 +4,14 @@
  * @return a random integer in the range 1 to 7
  */
 class Solution extends SolBase {
-    public int rand10() {
-        int temp = 0;
-        while (true) {
-            temp = (rand7() - 1) * 7 + (rand7() - 1);
-            if (temp < 40) {
-                break;
-            }
-        }
-        
-        return temp % 10 + 1;
+  public int rand10() {
+    int temp = 0;
+    while (true) {
+      temp = (rand7() - 1) * 7 + (rand7() - 1);
+      if (temp < 40) {
+        break;
+      }
     }
+    return temp % 10 + 1;
+  }
 }
diff --git a/Medium/Swap For Longest Repeated Character Substring.java b/Medium/Swap For Longest Repeated Character Substring.java
new file mode 100644
index 00000000..d09edb22
--- /dev/null
+++ b/Medium/Swap For Longest Repeated Character Substring.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int maxRepOpt1(String text) {
+    int[] count = new int[26];
+    for (char c : text.toCharArray()) {
+      count[c - 'a']++;
+    }
+    int maxCount = 0;
+    int i = 0;
+    while (i < text.length()) {
+      char c = text.charAt(i);
+      int curr = i;
+      int currCount = 0;
+      int diff = 0;
+      // To skip the same characters before we make a swap
+      int swapPoint = i;
+      while (curr < text.length() && (text.charAt(curr) == c || diff == 0) && currCount < count[c - 'a']) {
+        if (text.charAt(curr) != c) {
+          diff++;
+          swapPoint = curr - 1;
+        }
+        currCount++;
+        curr++;
+      }
+      maxCount = Math.max(maxCount, currCount);
+      i = swapPoint + 1;
+    }
+    return maxCount;
+  }
+}

From 5622751312f053d10a00098cffe431c75d89bf79 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 30 Aug 2020 09:33:24 -0500
Subject: [PATCH 0289/2175] Added 2 solutions

---
 ... of Length M Repeated K or More Times.java | 27 +++++++++++++++++++
 ...gth of Subarray With Positive Product.java | 25 +++++++++++++++++
 2 files changed, 52 insertions(+)
 create mode 100644 Easy/Detect Pattern of Length M Repeated K or More Times.java
 create mode 100644 Medium/Maximum Length of Subarray With Positive Product.java

diff --git a/Easy/Detect Pattern of Length M Repeated K or More Times.java b/Easy/Detect Pattern of Length M Repeated K or More Times.java
new file mode 100644
index 00000000..35a90fd2
--- /dev/null
+++ b/Easy/Detect Pattern of Length M Repeated K or More Times.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public boolean containsPattern(int[] arr, int m, int k) {
+    Queue<Integer> queue = new LinkedList<>();
+    int count = 0;
+    int freq = 1;
+    for (int i = 0; i < arr.length; i++) {
+      if (i >= m) {
+        if (arr[i] == queue.poll()) {
+          count++;
+          if (count == m) {
+            freq++;
+            count = 0;
+          }
+          if (freq == k) {
+            return true;
+          }
+        }
+        else {
+          count = 0;
+          freq = 1;
+        }
+      }
+      queue.add(arr[i]);
+    }
+    return false;
+  }
+}
diff --git a/Medium/Maximum Length of Subarray With Positive Product.java b/Medium/Maximum Length of Subarray With Positive Product.java
new file mode 100644
index 00000000..172d4d63
--- /dev/null
+++ b/Medium/Maximum Length of Subarray With Positive Product.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int getMaxLen(int[] nums) {
+    int startIndex = -1;
+    int firstNegativeIndex = -1;
+    int negativeCount = 0;
+    int maxLen = 0;
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] < 0) {
+        negativeCount++;
+        if (firstNegativeIndex == -1) {
+          firstNegativeIndex = i;
+        }
+      }
+      else if (nums[i] == 0) {
+        negativeCount = 0;
+        firstNegativeIndex = -1;
+        startIndex = i;
+      }
+      maxLen = Math.max(
+        maxLen, (negativeCount % 2 == 0 ? i - startIndex : i - firstNegativeIndex)
+      );
+    }
+    return maxLen;
+  }
+}

From a32f72bbf9e6486d4b2ff59f4fe49858c2020a12 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 31 Aug 2020 08:48:37 -0500
Subject: [PATCH 0290/2175] Modified Find Winner on a Tic Tac Toe Game.java

---
 Easy/Find Winner on a Tic Tac Toe Game.java | 77 +++++++++------------
 1 file changed, 33 insertions(+), 44 deletions(-)

diff --git a/Easy/Find Winner on a Tic Tac Toe Game.java b/Easy/Find Winner on a Tic Tac Toe Game.java
index c5a27339..4fc97260 100644
--- a/Easy/Find Winner on a Tic Tac Toe Game.java	
+++ b/Easy/Find Winner on a Tic Tac Toe Game.java	
@@ -1,49 +1,38 @@
 class Solution {
-    int[] rowCount;
-    int[] colCount;
-    int[] diagCount;
-    public String tictactoe(int[][] moves) {
-        rowCount = new int[3];
-        colCount = new int[3];
-        diagCount = new int[2];
-        int numOfMoves = 0;
-        for (int i = 0; i < moves.length; i++) {
-            int x = moves[i][0];
-            int y = moves[i][1];
-            int move = i % 2 == 0 ? 1 : -1;
-            updateBoard(x, y, move);
-            numOfMoves++;
-            if (checkForWinner(x, y)) {
-                return i % 2 == 0 ? "A" : "B";
-            }
+  public String tictactoe(int[][] moves) {
+    int n = 3;
+    Map<Integer, Map<Character, Integer>> rowMap = new HashMap<>();
+    Map<Integer, Map<Character, Integer>> colMap = new HashMap<>();
+    Map<Character, Integer> rightDiagMap = new HashMap<>();
+    Map<Character, Integer> leftDiagMap = new HashMap<>();
+    for (int i = 0; i < moves.length; i++) {
+      int x = moves[i][0];
+      int y = moves[i][1];
+      char move = i % 2 == 0 ? 'X' : 'O';
+      String player = i % 2 == 0 ? "A" : "B";
+      Map<Character, Integer> row = rowMap.computeIfAbsent(x, k -> new HashMap<>());
+      row.put(move, row.getOrDefault(move, 0) + 1);
+      if (row.get(move) == 3) {
+        return player;
+      }
+      Map<Character, Integer> col = colMap.computeIfAbsent(y, k -> new HashMap<>());
+      col.put(move, col.getOrDefault(move, 0) + 1);
+      if (col.get(move) == 3) {
+        return player;
+      }
+      if (x == y) {
+        leftDiagMap.put(move, leftDiagMap.getOrDefault(move, 0) + 1);
+        if (leftDiagMap.get(move) == 3) {
+          return player;
         }
-        return numOfMoves == 9 ? "Draw" : "Pending";
-    }
-    
-    private boolean checkForWinner(int x, int y) {
-        if (rowCount[x] == 3 || rowCount[x] == -3) {
-            return true;
-        }
-        if (colCount[y] == 3 || colCount[y] == -3) {
-            return true;
-        }
-        if (x == y && (diagCount[0] == 3 || diagCount[0] == -3)) {
-            return true;
-        }
-        if (x + y == 2 && (diagCount[1] == 3 || diagCount[1] == -3)) {
-            return true;
-        }
-        return false;
-    }
-    
-    private void updateBoard(int x, int y, int move) {
-        rowCount[x] += move;
-        colCount[y] += move;
-        if (x == y) {
-            diagCount[0] += move;
-        }
-        if (x + y == 2) {
-            diagCount[1] += move;
+      }
+      if (x + y == n - 1) {
+        rightDiagMap.put(move, rightDiagMap.getOrDefault(move, 0) + 1);
+        if (rightDiagMap.get(move) == 3) {
+          return player;
         }
+      }
     }
+    return moves.length == n * n ? "Draw" : "Pending";
+  }
 }

From bafda67bb5a6666d3809e35658b2eb45e25be4b0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 31 Aug 2020 20:34:12 -0500
Subject: [PATCH 0291/2175] Modified 3 solutions

---
 Easy/Jewels and Stones.java                  | 20 +++-----
 Medium/Remove Nth Node From End of List.java | 51 +++++++++-----------
 Medium/Subsets.java                          | 21 +++-----
 3 files changed, 39 insertions(+), 53 deletions(-)

diff --git a/Easy/Jewels and Stones.java b/Easy/Jewels and Stones.java
index 6a318480..f37c51ca 100644
--- a/Easy/Jewels and Stones.java	
+++ b/Easy/Jewels and Stones.java	
@@ -1,19 +1,15 @@
 class Solution {
   public int numJewelsInStones(String J, String S) {
-    Map<Character, Integer> mapJ = getMap(J);
-    Map<Character, Integer> mapS = getMap(S);
+    Set<Character> set = new HashSet<>();
+    for (char c : J.toCharArray()) {
+      set.add(c);
+    }
     int count = 0;
-    for (Character key : mapJ.keySet()) {
-      count += mapS.getOrDefault(key, 0);
+    for (char c : S.toCharArray()) {
+      if (set.contains(c)) {
+        count++;
+      }
     }
     return count;
   }
-  
-  private Map<Character, Integer> getMap(String s) {
-    Map<Character, Integer> map = new HashMap<>();
-    for (char c : s.toCharArray()) {
-      map.put(c, map.getOrDefault(c, 0) + 1);
-    }
-    return map;
-  }
 }
diff --git a/Medium/Remove Nth Node From End of List.java b/Medium/Remove Nth Node From End of List.java
index ae91da94..44b990bd 100644
--- a/Medium/Remove Nth Node From End of List.java	
+++ b/Medium/Remove Nth Node From End of List.java	
@@ -3,36 +3,31 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode removeNthFromEnd(ListNode head, int n) {
-        
-        if (head ==  null || head.next == null) return null;
-        
-        ListNode curr = head;
-        int i = 0;
-        
-        while (curr != null) {
-            curr = curr.next;
-            i++;
-        }
-        
-        if (i == n) {
-            return head.next;
-        }
-        
-        n = i - n;
-        i = 1;
-        curr = head;
-        
-        while (i != n) {
-            curr = curr.next;
-            i++;
-        }
-        curr.next = curr.next.next;
-        
-        return head;
+  public ListNode removeNthFromEnd(ListNode head, int n) {
+    if (head == null || n == 0) {
+      return head;
     }
+    ListNode slow = head;
+    int count = 0;
+    while (count < n) {
+      slow = slow.next;
+      count++;
+    }
+    if (slow == null) {
+      return head.next;
+    }
+    ListNode fast = head;
+    while (slow.next != null) {
+      slow = slow.next;
+      fast = fast.next;
+    }
+    fast.next = fast.next.next;
+    return head;
+  }
 }
diff --git a/Medium/Subsets.java b/Medium/Subsets.java
index 2bfb0c12..e86ccecd 100644
--- a/Medium/Subsets.java
+++ b/Medium/Subsets.java
@@ -1,24 +1,19 @@
 class Solution {
   public List<List<Integer>> subsets(int[] nums) {
     List<List<Integer>> list = new ArrayList<>();
-    List<Integer> curr = new ArrayList<>();
-    helper(list, curr, nums, 0, nums.length, new boolean[nums.length]);
+    helper(nums, list, new ArrayList<>(), 0);
     return list;
-  }   
+  }
   
-  private void helper(List<List<Integer>> list, List<Integer> curr, int[] nums, int idx, int n, boolean[] seen) {
+  private void helper(int[] nums, List<List<Integer>> list, List<Integer> curr, int idx) {
     list.add(new ArrayList<>(curr));
-    if (idx >= n) {
+    if (idx >= nums.length) {
       return;
     }
-    for (int i = idx; i < n; i++) {
-      if (!seen[i]) {
-        seen[i] = true;
-        curr.add(nums[i]);
-        helper(list, curr, nums, i + 1, n, seen);
-        seen[i] = false;
-        curr.remove(curr.size() - 1);
-      }
+    for (int i = idx; i < nums.length; i++) {
+      curr.add(nums[i]);
+      helper(nums, list, curr, i + 1);
+      curr.remove(curr.size() - 1);
     }
   }
 }

From e68a3dfc0422c23670b924e2cf3bfab1662c8dc6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 2 Sep 2020 09:49:02 -0500
Subject: [PATCH 0292/2175] Modified Contains Duplicate III.java

---
 Medium/Contains Duplicate III.java | 35 +++++++++++++-----------------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/Medium/Contains Duplicate III.java b/Medium/Contains Duplicate III.java
index 431d9e0a..7e271137 100644
--- a/Medium/Contains Duplicate III.java	
+++ b/Medium/Contains Duplicate III.java	
@@ -1,23 +1,18 @@
 class Solution {
-    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
-        TreeSet<Long> treeSet = new TreeSet<>();
-        for (int i=0; i<nums.length; i++) {
-            long num = nums[i];
-            Long floor = treeSet.floor(num + t);
-            Long ceil = treeSet.ceiling(num - t);
-
-            if (floor != null && floor >= nums[i] ||
-                ceil != null && ceil <= nums[i]) {
-                return true;
-            }
-
-            treeSet.add(num);
-
-            if (i >= k) {
-                treeSet.remove((long) nums[i - k]);
-            }
-        }
-
-        return false;
+  public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
+    TreeSet<Long> set = new TreeSet<>();
+    for (int i = 0; i < nums.length; i++) {
+      long num = nums[i];
+      Long floor = set.floor(num + t);
+      Long ceil = set.ceiling(num - t);
+      if ((floor != null && floor >= num) || (ceil != null && ceil <= num)) {
+        return true;
+      }
+      set.add(num);
+      if (i >= k) {
+        set.remove((long) nums[i - k]);
+      }
     }
+    return false;
+  }
 }

From a3421829d72a1734a6105187c4db6ab26ac8e81e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 4 Sep 2020 09:25:21 -0500
Subject: [PATCH 0293/2175] Modified 2 solutions

---
 Easy/Repeated Substring Pattern.java |  4 +--
 Medium/Partition Labels.java         | 43 ++++++++++++----------------
 2 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/Easy/Repeated Substring Pattern.java b/Easy/Repeated Substring Pattern.java
index e766601b..79ea250c 100644
--- a/Easy/Repeated Substring Pattern.java	
+++ b/Easy/Repeated Substring Pattern.java	
@@ -1,8 +1,8 @@
 class Solution {
   public boolean repeatedSubstringPattern(String s) {
     int n = s.length();
-    for (int i = n / 2; i >= 0; i--) {
-      if (i != 0 && n % i == 0) {
+    for (int i = n / 2; i >= 1; i--) {
+      if (n % i == 0) {
         int count = n / i;
         StringBuilder sb = new StringBuilder();
         String sub = s.substring(0, i);
diff --git a/Medium/Partition Labels.java b/Medium/Partition Labels.java
index 7608fcb5..c407b224 100644
--- a/Medium/Partition Labels.java	
+++ b/Medium/Partition Labels.java	
@@ -1,27 +1,22 @@
 class Solution {
-    public List<Integer> partitionLabels(String S) {
-        
-        if (S == null || S.length() == 0) return null;
-        
-        int[] map = new int[26];
-        
-        for (int i=0;i<S.length();i++) {
-            map[S.charAt(i) - 'a'] = i;
-        }
-        
-        List<Integer> ans = new ArrayList<Integer>();
-        
-        int end = 0;
-        int start = -1;
-        
-        for (int i=0;i<S.length();i++) {
-            end = Math.max(end, map[S.charAt(i) - 'a']);
-            if (end == i) {
-                ans.add(end-start);
-                start = end;
-            }
-        }
-        
-        return ans;
+  public List<Integer> partitionLabels(String S) {
+    if (S == null || S.length() == 0) {
+      return new ArrayList<>();
     }
+    int[] count = new int[26];
+    for (int i = 0; i < S.length(); i++) {
+      count[S.charAt(i) - 'a'] = i;
+    }
+    int start = -1;
+    int end = 0;
+    List<Integer> list = new ArrayList<>();
+    for (int i = 0; i < S.length(); i++) {
+      end = Math.max(end, count[S.charAt(i) - 'a']);
+      if (end == i) {
+        list.add(end - start);
+        start = end;
+      }
+    }
+    return list;
+  }
 }

From b703f4e0754ca9b8d66e8d4dd241e6f5d48219d2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 4 Sep 2020 13:08:46 -0500
Subject: [PATCH 0294/2175] Added 2 solutions

---
 ...Integer Solution for a Given Equation.java | 28 +++++++++++++++++
 ... Make All Paths Lead to the City Zero.java | 30 +++++++++++++++++++
 2 files changed, 58 insertions(+)
 create mode 100644 Easy/Find Positive Integer Solution for a Given Equation.java
 create mode 100644 Medium/Reorder Routes to Make All Paths Lead to the City Zero.java

diff --git a/Easy/Find Positive Integer Solution for a Given Equation.java b/Easy/Find Positive Integer Solution for a Given Equation.java
new file mode 100644
index 00000000..4f6b7bce
--- /dev/null
+++ b/Easy/Find Positive Integer Solution for a Given Equation.java	
@@ -0,0 +1,28 @@
+/*
+ * // This is the custom function interface.
+ * // You should not implement it, or speculate about its implementation
+ * class CustomFunction {
+ *     // Returns f(x, y) for any given positive integers x and y.
+ *     // Note that f(x, y) is increasing with respect to both x and y.
+ *     // i.e. f(x, y) < f(x + 1, y), f(x, y) < f(x, y + 1)
+ *     public int f(int x, int y);
+ * };
+ */
+
+class Solution {
+  public List<List<Integer>> findSolution(CustomFunction customfunction, int z) {
+    List<List<Integer>> list = new ArrayList<>();
+    for (int i = 1; i <= z; i++) {
+      for (int j = 1; j <= z; j++) {
+        int val = customfunction.f(i, j);
+        if (val == z) {
+          list.add(Arrays.asList(i, j));
+        }
+        if (val > z) {
+          break;
+        }
+      }
+    }
+    return list;
+  }
+}
diff --git a/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java b/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java
new file mode 100644
index 00000000..121798de
--- /dev/null
+++ b/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public int minReorder(int n, int[][] connections) {
+    Map<Integer, Set<Integer>> map = new HashMap<>();
+    Set<String> set = new HashSet<>();
+    for (int[] connection : connections) {
+      map.computeIfAbsent(connection[0], k -> new HashSet<>()).add(connection[1]);
+      map.computeIfAbsent(connection[1], k -> new HashSet<>()).add(connection[0]);
+      set.add(connection[0] + "->" + connection[1]);
+    }
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(0);
+    int numOfReorders = 0;
+    boolean[] visited = new boolean[n];
+    visited[0] = true;
+    while (!queue.isEmpty()) {
+      int removed = queue.remove();
+      for (int connection : map.getOrDefault(removed, new HashSet<>())) {
+        if (visited[connection]) {
+          continue;
+        }
+        visited[connection] = true;
+        if (!set.contains(connection + "->" + removed)) {
+          numOfReorders++;
+        }
+        queue.add(connection);
+      }
+    }
+    return numOfReorders;
+  }
+}

From 78fbb0c3689037567a60e8e242277aaa65180046 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 5 Sep 2020 09:00:16 -0500
Subject: [PATCH 0295/2175] Modified All Elements in Two Binary Search
 Trees.java

---
 ...l Elements in Two Binary Search Trees.java | 53 ++++++++++---------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/Medium/All Elements in Two Binary Search Trees.java b/Medium/All Elements in Two Binary Search Trees.java
index 4c535e00..a973fd93 100644
--- a/Medium/All Elements in Two Binary Search Trees.java	
+++ b/Medium/All Elements in Two Binary Search Trees.java	
@@ -4,49 +4,50 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  List<Integer> ans;
   public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
-    ans = new ArrayList<>();
-    helper(root1, root2);
-    return ans;
-  }
-  
-  private void helper(TreeNode r1, TreeNode r2) {
     Stack<TreeNode> stack1 = new Stack<>();
     Stack<TreeNode> stack2 = new Stack<>();
-    addToStack(stack1, r1);
-    addToStack(stack2, r2);
+    updateStack(stack1, root1);
+    updateStack(stack2, root2);
+    List<Integer> list = new ArrayList<>();
     while (!stack1.isEmpty() || !stack2.isEmpty()) {
-      TreeNode popped1 = stack1.isEmpty() ? null : stack1.pop();
-      TreeNode popped2 = stack2.isEmpty() ? null : stack2.pop();
-      if (popped1 != null && popped2 != null) {
-        if (popped1.val > popped2.val) {
-          ans.add(popped2.val);
-          addToStack(stack2, popped2.right);
-          stack1.push(popped1);
+      if (!stack1.isEmpty() && !stack2.isEmpty()) {
+        if (stack1.peek().val < stack2.peek().val) {
+          TreeNode popped = stack1.pop();
+          list.add(popped.val);
+          updateStack(stack1, popped.right);
         }
         else {
-          ans.add(popped1.val);
-          addToStack(stack1, popped1.right);
-          stack2.push(popped2);
+          TreeNode popped = stack2.pop();
+          list.add(popped.val);
+          updateStack(stack2, popped.right);
         }
       }
-      else if (popped2 == null) {
-        ans.add(popped1.val);
-        addToStack(stack1, popped1.right);
+      else if (!stack1.isEmpty() && stack2.isEmpty()) {
+        TreeNode popped = stack1.pop();
+        list.add(popped.val);
+        updateStack(stack1, popped.right);
       }
       else {
-        ans.add(popped2.val);
-        addToStack(stack2, popped2.right);
+        TreeNode popped = stack2.pop();
+        list.add(popped.val);
+        updateStack(stack2, popped.right);
       }
     }
+    return list;
   }
   
-  private void addToStack(Stack<TreeNode> stack, TreeNode node) {
+  private void updateStack(Stack<TreeNode> stack, TreeNode node) {
     while (node != null) {
       stack.push(node);
       node = node.left;

From 2b91995569e67c86464389a69bdc8b7112f7163e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 5 Sep 2020 16:16:00 -0500
Subject: [PATCH 0296/2175] Added Matrix Diagonal Sum.java

---
 Easy/Matrix Diagonal Sum.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Matrix Diagonal Sum.java

diff --git a/Easy/Matrix Diagonal Sum.java b/Easy/Matrix Diagonal Sum.java
new file mode 100644
index 00000000..772421b7
--- /dev/null
+++ b/Easy/Matrix Diagonal Sum.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int diagonalSum(int[][] mat) {
+    int sum = 0;
+    // Left -> Right Diagonal
+    for (int i = 0; i < mat.length; i++) {
+      sum += mat[i][i];
+    }
+    // Right -> Left Diagonal
+    int rowIdx = 0;
+    int colIdx = mat[0].length - 1;
+    while (rowIdx < mat.length) {
+      // Check to remove intersecting element in both diagonals
+      if (rowIdx != colIdx) {
+        sum += mat[rowIdx][colIdx];
+      }
+      rowIdx++;
+      colIdx--;
+    }
+    return sum;
+  }
+}

From 2f058e700028fdd935d5fd74c7865170971f0f41 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 7 Sep 2020 14:35:19 -0500
Subject: [PATCH 0297/2175] Modified Word Pattern.java

---
 Easy/Word Pattern.java | 50 +++++++++++++++++-------------------------
 1 file changed, 20 insertions(+), 30 deletions(-)

diff --git a/Easy/Word Pattern.java b/Easy/Word Pattern.java
index 2617c650..5f62cf62 100644
--- a/Easy/Word Pattern.java	
+++ b/Easy/Word Pattern.java	
@@ -1,33 +1,23 @@
 class Solution {
-    public boolean wordPattern(String pattern, String str) {
-        Map<Character, Integer> patternMap = new HashMap<>();
-        StringBuilder patternCode = new StringBuilder();
-        int maxVal = 1;
-        
-        for (char c : pattern.toCharArray()) {
-            if (patternMap.containsKey(c)) {
-                patternCode.append(patternMap.get(c));
-            }
-            else {
-                patternMap.put(c, maxVal++);
-                patternCode.append(patternMap.get(c));
-            }
-        }
-        
-        Map<String, Integer> strMap = new HashMap<>();
-        StringBuilder strCode = new StringBuilder();
-        maxVal = 1;
-        
-        for (String s : str.trim().split("\\s+")) {
-            if (strMap.containsKey(s)) {
-                strCode.append(strMap.get(s));
-            }
-            else {
-                strMap.put(s, maxVal++);
-                strCode.append(strMap.get(s));
-            }
-        }
-        
-        return patternCode.toString().equals(strCode.toString());
+  public boolean wordPattern(String pattern, String str) {
+    StringBuilder patternSb = new StringBuilder();
+    Map<Character, Integer> patternMap = new HashMap<>();
+    int count = 0;
+    for (char c : pattern.toCharArray()) {
+      if (!patternMap.containsKey(c)) {
+        patternMap.put(c, count++);
+      }
+      patternSb.append(patternMap.get(c));
     }
+    StringBuilder strSb = new StringBuilder();
+    Map<String, Integer> strMap = new HashMap<>();
+    count = 0;
+    for (String s : str.split("\\s+")) {
+      if (!strMap.containsKey(s)) {
+        strMap.put(s, count++);
+      }
+      strSb.append(strMap.get(s));
+    }
+    return patternSb.toString().equals(strSb.toString());
+  }
 }

From 4ab1d11baa1e3e7bc5eb1ff8a56f64db54f72da7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 7 Sep 2020 17:22:16 -0500
Subject: [PATCH 0298/2175] Added Minimum Deletion Cost to Avoid Repeating
 Letters.java

---
 ...etion Cost to Avoid Repeating Letters.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Minimum Deletion Cost to Avoid Repeating Letters.java

diff --git a/Medium/Minimum Deletion Cost to Avoid Repeating Letters.java b/Medium/Minimum Deletion Cost to Avoid Repeating Letters.java
new file mode 100644
index 00000000..cddb0210
--- /dev/null
+++ b/Medium/Minimum Deletion Cost to Avoid Repeating Letters.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int minCost(String s, int[] cost) {
+    Stack<Integer> stack = new Stack<>();
+    int deletionCost = 0;
+    for (int i = 0; i < s.length(); i++) {
+      int insertionIndex = i;
+      if (!stack.isEmpty() && s.charAt(i) == s.charAt(stack.peek())) {
+        int poppedIdx = stack.pop();
+        if (cost[i] > cost[poppedIdx]) {
+          deletionCost += cost[poppedIdx];
+        }
+        else {
+          deletionCost += cost[i];
+          insertionIndex = poppedIdx;
+        }
+      }
+      stack.push(insertionIndex);
+    }
+    return deletionCost;
+  }
+}

From 3e92511cdccc0afcc530d9bab7d215a84d3b5e13 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 9 Sep 2020 16:40:14 -0500
Subject: [PATCH 0299/2175] Added Shortest Completing Word.java

---
 Easy/Shortest Completing Word.java           | 33 +++++++++++++++++
 Easy/Sum of Root To Leaf Binary Numbers.java | 39 ++++++++++----------
 2 files changed, 53 insertions(+), 19 deletions(-)
 create mode 100644 Easy/Shortest Completing Word.java

diff --git a/Easy/Shortest Completing Word.java b/Easy/Shortest Completing Word.java
new file mode 100644
index 00000000..1be5e2f8
--- /dev/null
+++ b/Easy/Shortest Completing Word.java	
@@ -0,0 +1,33 @@
+class Solution {
+  public String shortestCompletingWord(String licensePlate, String[] words) {
+    Map<Character, Integer> licenseMap = new HashMap<>();
+    for (Character c : licensePlate.toCharArray()) {
+      if (Character.isLetter(c)) {
+        licenseMap.put(Character.toLowerCase(c), licenseMap.getOrDefault(Character.toLowerCase(c), 0) + 1);
+      }
+    }
+    int minLength = Integer.MAX_VALUE;
+    int minLengthIdx = -1;
+    for (int i = 0; i < words.length; i++) {
+      Map<Character, Integer> copyMap = new HashMap<>(licenseMap);
+      boolean found = false;
+      for (Character c : words[i].toCharArray()) {
+        if (copyMap.containsKey(Character.toLowerCase(c))) {
+          copyMap.put(Character.toLowerCase(c), copyMap.get(Character.toLowerCase(c)) - 1);
+          if (copyMap.get(Character.toLowerCase(c)) == 0) {
+            copyMap.remove(Character.toLowerCase(c));
+          }
+        }
+        if (copyMap.size() == 0) {
+          found = true;
+          break;
+        }
+      }
+      if (found && words[i].length() < minLength) {
+        minLength = words[i].length();
+        minLengthIdx = i;
+      }
+    }
+    return words[minLengthIdx];
+  }
+}
diff --git a/Easy/Sum of Root To Leaf Binary Numbers.java b/Easy/Sum of Root To Leaf Binary Numbers.java
index 38f871ec..135a6c6a 100644
--- a/Easy/Sum of Root To Leaf Binary Numbers.java	
+++ b/Easy/Sum of Root To Leaf Binary Numbers.java	
@@ -4,42 +4,43 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  List<String> list;
   public int sumRootToLeaf(TreeNode root) {
-    list = new ArrayList<>();
-    helper(root, new StringBuilder());
-    int ans = 0;
-    for (String num : list) {
-      ans += getIntegerVal(num);
-    }
-    return ans;
+    int[] sum = {0};
+    helper(root, new StringBuilder(), sum);
+    return sum[0];
   }
   
-  private void helper(TreeNode root, StringBuilder sb) {
+  private void helper(TreeNode root, StringBuilder sb, int[] sum) {
     if (root == null) {
       return;
     }
     sb.append(root.val);
     if (root.left == null && root.right == null) {
-      list.add(sb.toString());
+      sum[0] += getDecimalValue(sb.toString());
     }
     else {
-      helper(root.left, new StringBuilder(sb.toString()));
-      helper(root.right, new StringBuilder(sb.toString()));
+      helper(root.left, new StringBuilder(sb.toString()), sum);
+      helper(root.right, new StringBuilder(sb.toString()), sum);
     }
   }
   
-  private int getIntegerVal(String s) {
-    int num = 0;
-    int pow = 1;
+  private int getDecimalValue(String s) {
+    int val = 0;
+    int mul = 1;
     for (int i = s.length() - 1; i >= 0; i--) {
-      num += Character.getNumericValue(s.charAt(i)) * pow;
-      pow *= 2;
+      val += mul * (s.charAt(i) == '1' ? 1 : 0);
+      mul *= 2;
     }
-    return num;
+    return val;
   }
 }

From b618289969c59a7954a7b087de7b7ad2bd2ba92e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 10 Sep 2020 07:51:37 -0500
Subject: [PATCH 0300/2175] Modified 2 solutions

---
 Easy/Bulls and Cows.java      | 23 +++++++++--------------
 Medium/Arithmetic Slices.java | 27 ++++++++++++++-------------
 2 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/Easy/Bulls and Cows.java b/Easy/Bulls and Cows.java
index 5a2b5ef7..d071ff1d 100644
--- a/Easy/Bulls and Cows.java	
+++ b/Easy/Bulls and Cows.java	
@@ -1,25 +1,20 @@
 class Solution {
   public String getHint(String secret, String guess) {
     int[] counter = new int[10];
-    int cows = 0;
+    for (Character c : secret.toCharArray()) {
+      counter[Character.getNumericValue(c)]++;
+    }
     int bulls = 0;
+    int cows = 0;
     for (int i = 0; i < guess.length(); i++) {
-      int s = Character.getNumericValue(secret.charAt(i));
-      int g = Character.getNumericValue(guess.charAt(i));
-      if (s == g) {
+      if (guess.charAt(i) == secret.charAt(i)) {
         bulls++;
       }
-      else {
-        if (counter[s] < 0) {
-          cows++;
-        }
-        if (counter[g] > 0) {
-          cows++;
-        }
-        counter[s]++;
-        counter[g]--;
+      if (counter[Character.getNumericValue(guess.charAt(i))] > 0) {
+        counter[Character.getNumericValue(guess.charAt(i))]--;
+        cows++;
       }
     }
-    return new StringBuilder().append(bulls).append("A").append(cows).append("B").toString();
+    return bulls + "A" + (cows - bulls) + "B";
   }
 }
diff --git a/Medium/Arithmetic Slices.java b/Medium/Arithmetic Slices.java
index 4424c084..67a68778 100644
--- a/Medium/Arithmetic Slices.java	
+++ b/Medium/Arithmetic Slices.java	
@@ -1,16 +1,17 @@
 class Solution {
-    public int numberOfArithmeticSlices(int[] A) {
-        
-        int curr = 0, sum = 0;
-        for (int i=2; i<A.length; i++)
-            if (A[i]-A[i-1] == A[i-1]-A[i-2]) {
-                curr += 1;
-                sum += curr;
-            } 
-            else {
-                curr = 0;
-            }
-
-        return sum;
+  public int numberOfArithmeticSlices(int[] A) {
+    int count = 0;
+    for (int i = 0; i < A.length - 2; i++) {
+      int diff = A[i + 1] - A[i];
+      for (int j = i + 2; j < A.length; j++) {
+        if (A[j] - A[j - 1] == diff) {
+          count++;
+        }
+        else {
+          break;
+        }
+      }
     }
+    return count;
+  }
 }

From 21f0fdb0e6f32248f212b2bc2b616ccf0dac7c4e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 11 Sep 2020 09:18:52 -0500
Subject: [PATCH 0301/2175] Modified Maximum Product Subarray.java

---
 Medium/Maximum Product Subarray.java | 25 +++++++++++--------------
 1 file changed, 11 insertions(+), 14 deletions(-)

diff --git a/Medium/Maximum Product Subarray.java b/Medium/Maximum Product Subarray.java
index 770a69cf..a7f12091 100644
--- a/Medium/Maximum Product Subarray.java	
+++ b/Medium/Maximum Product Subarray.java	
@@ -1,17 +1,14 @@
 class Solution {
-    public int maxProduct(int[] nums) {
-        int max = nums[0];
-        int min = nums[0];
-        int maxGlobal = max;
-        
-        for (int i = 1; i < nums.length; i++) {
-            int temp = max;
-            max = Math.max(Math.max(nums[i] * temp, nums[i] * min), nums[i]);
-            min = Math.min(Math.min(nums[i] * temp, nums[i] * min), nums[i]);
-            
-            maxGlobal = Math.max(max, maxGlobal);
-        }
-        
-        return maxGlobal;
+  public int maxProduct(int[] nums) {
+    int currMax = nums[0];
+    int currMin = nums[0];
+    int maxProd = currMax;
+    for (int i = 1; i < nums.length; i++) {
+      int temp = currMax;
+      currMax = Math.max(Math.max(temp * nums[i], currMin * nums[i]), nums[i]);
+      currMin = Math.min(Math.min(temp * nums[i], currMin * nums[i]), nums[i]);
+      maxProd = Math.max(maxProd, currMax);
     }
+    return maxProd;
+  }
 }

From 581d81428a695719b96920975e9ff18b72d1d859 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 12 Sep 2020 08:04:45 -0500
Subject: [PATCH 0302/2175] Modified Combination Sum III.java

---
 Medium/Combination Sum III.java | 43 +++++++++++++--------------------
 1 file changed, 17 insertions(+), 26 deletions(-)

diff --git a/Medium/Combination Sum III.java b/Medium/Combination Sum III.java
index 61fa4257..4acafbfc 100644
--- a/Medium/Combination Sum III.java	
+++ b/Medium/Combination Sum III.java	
@@ -1,30 +1,21 @@
 class Solution {
-    public List<List<Integer>> combinationSum3(int k, int n) {
-        List<List<Integer>> list = new ArrayList<>();
-        List<Integer> temp = new ArrayList<>();
-
-        helper(list, temp, k, n, 0, 1);
-
-        return list;
+  public List<List<Integer>> combinationSum3(int k, int n) {
+    List<List<Integer>> lists = new ArrayList<>();
+    helper(n, lists, new ArrayList<>(), 0, k, 1);
+    return lists;
+  }
+  
+  private void helper(int n, List<List<Integer>> lists, List<Integer> list, int currSum, int k, int currNum) {
+    if (list.size() == k) {
+      if (currSum == n) {
+        lists.add(new ArrayList<>(list));
+      }
+      return;
     }
-
-    private void helper(List<List<Integer>> list, List<Integer> temp, int k, int n, int sum, int start) {
-        if (sum == n && temp.size() == k) {
-            list.add(new ArrayList<>(temp));
-            return;
-        }
-
-        for (int i=start; i<=9; i++) {
-            // Choose
-            temp.add(i);
-            sum += i;
-
-            // Explore
-            helper(list, temp, k, n, sum, i+1);
-
-            // Un-choose
-            sum -= temp.get(temp.size() - 1);
-            temp.remove(temp.size() - 1);
-        }
+    for (int i = currNum; i <= 9; i++) {
+      list.add(i);
+      helper(n, lists, list, currSum + i, k, i + 1);
+      list.remove(list.size() - 1);
     }
+  }
 }

From 081651fb39de788d8fe5d1ef2bdebb8714ac6e3e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 12 Sep 2020 12:45:04 -0500
Subject: [PATCH 0303/2175] Added Maximum Sum BST in Binary Tree.java

---
 Hard/Maximum Sum BST in Binary Tree.java | 39 ++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Hard/Maximum Sum BST in Binary Tree.java

diff --git a/Hard/Maximum Sum BST in Binary Tree.java b/Hard/Maximum Sum BST in Binary Tree.java
new file mode 100644
index 00000000..eff81a2a
--- /dev/null
+++ b/Hard/Maximum Sum BST in Binary Tree.java	
@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int maxSumBST(TreeNode root) {
+    int[] ans = {0};
+    helper(root, ans);
+    return ans[0];
+  }
+  
+  private int[] helper(TreeNode root, int[] ans) {
+    if (root == null) {
+      // new int[]{min, max, sum}
+      return new int[]{Integer.MAX_VALUE, Integer.MIN_VALUE, 0};
+    }
+    int[] left = helper(root.left, ans);
+    int[] right = helper(root.right, ans);
+    if (!(left != null && right != null && root.val > left[1] && root.val < right[0])) {
+      return null;
+    }
+    int sum = root.val + left[2] + right[2];
+    ans[0] = Math.max(ans[0], sum);
+    int min = Math.min(root.val, left[0]);
+    int max = Math.max(root.val, right[1]);
+    return new int[]{min, max, sum};
+  }
+}

From 62180d84611f35d8bd6f116bffb3d0a508d9b2e1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 13 Sep 2020 09:35:54 -0500
Subject: [PATCH 0304/2175] Added Special Positions in a Binary Matrix.java

---
 .../Special Positions in a Binary Matrix.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Special Positions in a Binary Matrix.java

diff --git a/Easy/Special Positions in a Binary Matrix.java b/Easy/Special Positions in a Binary Matrix.java
new file mode 100644
index 00000000..fa5c8e56
--- /dev/null
+++ b/Easy/Special Positions in a Binary Matrix.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int numSpecial(int[][] mat) {
+    int[] rowCount = new int[mat.length];
+    int[] colCount = new int[mat[0].length];
+    for (int i = 0; i < mat.length; i++) {
+      for (int j = 0; j < mat[0].length; j++) {
+        if (mat[i][j] == 1) {
+          rowCount[i]++;
+          colCount[j]++;
+        }
+      }
+    }
+    int count = 0;
+    for (int i = 0; i < mat.length; i++) {
+      for (int j = 0; j < mat[0].length; j++) {
+        if (mat[i][j] == 1 && rowCount[i] == 1 && colCount[j] == 1) {
+          count++;
+        }
+      }
+    }
+    return count;
+  } 
+}

From 473f108ec21fe2825fd34b922c684c4e3bcafa9f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 14 Sep 2020 11:16:23 -0500
Subject: [PATCH 0305/2175] Added 1 solution & modified 2 solutions

---
 Easy/House Robber.java               | 16 +++++++-----
 Easy/Transpose Matrix.java           | 24 ++++++++---------
 Hard/Number of Squareful Arrays.java | 39 ++++++++++++++++++++++++++++
 3 files changed, 59 insertions(+), 20 deletions(-)
 create mode 100644 Hard/Number of Squareful Arrays.java

diff --git a/Easy/House Robber.java b/Easy/House Robber.java
index 6dc13216..6ec92f46 100644
--- a/Easy/House Robber.java	
+++ b/Easy/House Robber.java	
@@ -1,12 +1,14 @@
 class Solution {
   public int rob(int[] nums) {
-    int prev = 0;
-    int curr = 0;
-    for (int num : nums) {
-      int temp = curr;
-      curr = Math.max(prev + num, curr);
-      prev = temp;
+    if (nums.length == 0) {
+      return 0;
     }
-    return curr;
+    int[] dp = new int[nums.length + 1];
+    dp[0] = 0;
+    dp[1] = nums[0];
+    for (int i = 1; i < nums.length; i++) {
+      dp[i + 1] = Math.max(dp[i], dp[i - 1] + nums[i]);
+    }
+    return dp[nums.length];
   }
 }
diff --git a/Easy/Transpose Matrix.java b/Easy/Transpose Matrix.java
index ab25adb9..f59cb99f 100644
--- a/Easy/Transpose Matrix.java	
+++ b/Easy/Transpose Matrix.java	
@@ -1,16 +1,14 @@
 class Solution {
-    public int[][] transpose(int[][] A) {
-        int rows = A.length;
-        int columns = A[0].length;
-
-        int[][] newArr = new int[columns][rows];
-
-        for (int i=0; i<columns; i++) {
-            for (int j=0; j<rows; j++) {
-                newArr[i][j] = A[j][i];
-            }
-        }
-
-        return newArr;
+  public int[][] transpose(int[][] A) {
+    if (A.length == 0 || A[0].length == 0) {
+      return A;
     }
+    int[][] ans = new int[A[0].length][A.length];
+    for (int i = 0; i < A[0].length; i++) {
+      for (int j = 0; j < A.length; j++) {
+        ans[i][j] = A[j][i];
+      }
+    }
+    return ans;
+  }
 }
diff --git a/Hard/Number of Squareful Arrays.java b/Hard/Number of Squareful Arrays.java
new file mode 100644
index 00000000..5903c367
--- /dev/null
+++ b/Hard/Number of Squareful Arrays.java	
@@ -0,0 +1,39 @@
+class Solution {
+  public int numSquarefulPerms(int[] A) {
+    Map<Integer, Integer> count = new HashMap<>();
+    Map<Integer, List<Integer>> graph = new HashMap<>();
+    int n = A.length;
+    for (int num : A) {
+      count.put(num, count.getOrDefault(num, 0) + 1);
+    }
+    for (Integer key1 : count.keySet()) {
+      graph.computeIfAbsent(key1, k -> new ArrayList<>());
+      for (Integer key2 : count.keySet()) {
+        int r = (int) (Math.sqrt(key1 + key2) + 0.5);
+        if (r * r == key1 + key2) {
+          graph.get(key1).add(key2);
+        }
+      }
+    }
+    int ans = 0;
+    for (Integer key : count.keySet()) {
+      ans += dfs(key, n - 1, count, graph);
+    }
+    return ans;
+  }
+  
+  private int dfs(int key, int toReach, Map<Integer, Integer> count, Map<Integer, List<Integer>> graph) {
+    count.put(key, count.get(key) - 1);
+    int currAns = 1;
+    if (toReach != 0) {
+      currAns = 0;
+      for (int node : graph.get(key)) {
+        if (count.get(node) != 0) {
+          currAns += dfs(node, toReach - 1, count, graph);
+        }
+      }
+    }
+    count.put(key, count.get(key) + 1);
+    return currAns;
+  }
+}

From 8c14cc52f38c1daff7f4613637378699591d5d0f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 15 Sep 2020 09:14:13 -0500
Subject: [PATCH 0306/2175] Modified Inorder Successor in BST II.java

---
 Medium/Inorder Successor in BST II.java | 50 ++++++++++++-------------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/Medium/Inorder Successor in BST II.java b/Medium/Inorder Successor in BST II.java
index c78e42b7..d6810587 100644
--- a/Medium/Inorder Successor in BST II.java	
+++ b/Medium/Inorder Successor in BST II.java	
@@ -7,34 +7,30 @@ class Node {
     public Node parent;
 };
 */
+
 class Solution {
-    public Node inorderSuccessor(Node x) {
-        
-        // If right node exists => Find lowest value in right node. 
-        if (x.right != null) {
-            Node node = x.right;
-            
-            while (node.left != null) {
-                node = node.left;
-            }
-            
-            return node;
-        }
-        
-        // Find the first left which a node took to reach the node x
-        Node parent = x.parent;
-        Node lastNode = x;
-        Node lastLeft = null;
-        
-        while (parent != null) {
-            if (parent.left == lastNode && lastLeft == null) {
-                lastLeft = parent;
-            }
-            
-            lastNode = parent;
-            parent = parent.parent;
+  public Node inorderSuccessor(Node node) {
+    if (node == null) {
+      return null;
+    }
+    if (node.right != null) {
+      Node rightNode = node.right;
+      while (rightNode.left != null) {
+        rightNode = rightNode.left;
+      }
+      return rightNode;
+    }
+    else {
+      Node curr = node;
+      Node parentNode = node.parent;
+      while (parentNode != null) {
+        if (parentNode.left == curr) {
+          return parentNode;
         }
-        
-        return lastLeft;
+        curr = parentNode;
+        parentNode = parentNode.parent;
+      }
     }
+	return null;
+  }
 }

From 976febdaf6164d024e3c4d58836a3175cbc40c14 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 16 Sep 2020 08:44:03 -0500
Subject: [PATCH 0307/2175] Added Maximum XOR of Two Numbers in an Array.java

---
 ...aximum XOR of Two Numbers in an Array.java | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Maximum XOR of Two Numbers in an Array.java

diff --git a/Medium/Maximum XOR of Two Numbers in an Array.java b/Medium/Maximum XOR of Two Numbers in an Array.java
new file mode 100644
index 00000000..144ce0bc
--- /dev/null
+++ b/Medium/Maximum XOR of Two Numbers in an Array.java	
@@ -0,0 +1,42 @@
+class Solution {
+  public int findMaximumXOR(int[] nums) {
+    if (nums.length == 0) {
+      return 0;
+    }
+    Trie root = new Trie();
+    for (int num : nums) {
+      Trie curr = root;
+      for (int i = 31; i >= 0; i--) {
+        int currBit = (num >>> i) & 1;
+        if (curr.children[currBit] == null) {
+          curr.children[currBit] = new Trie();
+        }
+        curr = curr.children[currBit];
+      }
+    }
+    int maxVal = Integer.MIN_VALUE;
+    for (int num : nums) {
+      Trie curr = root;
+      int currVal = 0;
+      for (int i = 31; i >= 0; i--) {
+        int currBit = (num >>> i) & 1;
+        if (curr.children[currBit ^ 1] != null) {
+          currVal += (1 << i);
+          curr = curr.children[currBit ^ 1];
+        }
+        else {
+          curr = curr.children[currBit];
+        }
+      }
+      maxVal = Math.max(maxVal, currVal);
+    }
+    return maxVal;
+  }
+}
+
+class Trie {
+  Trie[] children;
+  public Trie() {
+    children = new Trie[2];
+  }
+}

From 660c6e41513b06923e5a9fea0d29d1bfcc5a8890 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 17 Sep 2020 10:06:55 -0500
Subject: [PATCH 0308/2175] Added Robot Bounded In Circle.java

---
 Medium/Robot Bounded In Circle.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Robot Bounded In Circle.java

diff --git a/Medium/Robot Bounded In Circle.java b/Medium/Robot Bounded In Circle.java
new file mode 100644
index 00000000..f3942994
--- /dev/null
+++ b/Medium/Robot Bounded In Circle.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public boolean isRobotBounded(String instructions) {
+    int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+    int x = 0;
+    int y = 0;
+    int idx = 0;
+    for (char c : instructions.toCharArray()) {
+      if (c == 'L') {
+        idx = (idx + 3) % 4;
+      }
+      else if (c == 'R') {
+        idx = (idx + 1) % 4;
+      }
+      else {
+        x += directions[idx][0];
+        y += directions[idx][1];
+      }
+    }
+    return (x == 0 && y == 0) || idx != 0;
+  }
+}

From 3b18e1b8d77781aee117523942c6babb3cb65fa5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 20 Sep 2020 09:53:53 -0500
Subject: [PATCH 0309/2175] Added 2 solutions

---
 Easy/Rearrange Spaces Between Words.java  | 34 +++++++++++++++++++++++
 Easy/Sum of All Odd Length Subarrays.java | 15 ++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 Easy/Rearrange Spaces Between Words.java
 create mode 100644 Easy/Sum of All Odd Length Subarrays.java

diff --git a/Easy/Rearrange Spaces Between Words.java b/Easy/Rearrange Spaces Between Words.java
new file mode 100644
index 00000000..25cc28e2
--- /dev/null
+++ b/Easy/Rearrange Spaces Between Words.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public String reorderSpaces(String text) {
+    int totalSpaces = 0;
+    StringBuilder sb = new StringBuilder();
+    List<String> words = new ArrayList<>();
+    for (int i = 0; i < text.length(); i++) {
+      char c = text.charAt(i);
+      if (c == ' ') {
+        totalSpaces++;
+        if (sb.length() > 0) {
+          words.add(sb.toString());
+          sb.setLength(0);
+        }
+      }
+      else {
+        sb.append(c);
+      }
+      if (i == text.length() - 1 && sb.length() > 0) {
+        words.add(sb.toString());
+        sb.setLength(0);
+      }
+    }
+    int batchSize = totalSpaces / (words.size() > 1 ? (words.size() - 1) : 1);
+    int remainingSpace = words.size() > 1 ? totalSpaces % (words.size() - 1)  : totalSpaces;
+    String space = String.join("", Collections.nCopies(batchSize, " "));
+    sb.append(words.get(0));
+    for (int i = 1; i < words.size(); i++) {
+      sb.append(space.toString());
+      sb.append(words.get(i));
+    }
+    sb.append(String.join("", Collections.nCopies(remainingSpace, " ")));
+    return sb.toString();
+  }
+}
diff --git a/Easy/Sum of All Odd Length Subarrays.java b/Easy/Sum of All Odd Length Subarrays.java
new file mode 100644
index 00000000..4127387b
--- /dev/null
+++ b/Easy/Sum of All Odd Length Subarrays.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int sumOddLengthSubarrays(int[] arr) {
+    int sum = 0;
+    for (int i = 0; i < arr.length; i++) {
+      int currSum = 0;
+      for (int j = i; j < arr.length; j++) {
+        currSum += arr[j];
+        if ((j - i + 1) % 2 != 0) {
+          sum += currSum;
+        }
+      }
+    }
+    return sum;
+  }
+}

From 1b450779f4d6a98e586683525b15310578547eb2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 20 Sep 2020 15:15:14 -0500
Subject: [PATCH 0310/2175] Modified Unique Paths III.java

---
 Hard/Unique Paths III.java | 102 +++++++++++++++----------------------
 1 file changed, 42 insertions(+), 60 deletions(-)

diff --git a/Hard/Unique Paths III.java b/Hard/Unique Paths III.java
index d1af98f1..415cbc9c 100644
--- a/Hard/Unique Paths III.java	
+++ b/Hard/Unique Paths III.java	
@@ -1,66 +1,48 @@
 class Solution {
-    int numOfPaths;
-
-    public int uniquePathsIII(int[][] grid) {
-        numOfPaths = 0;
-        if (grid.length == 0 || grid[0].length == 0) {
-            return numOfPaths;
-        }
-
-        int startX = -1;
-        int startY = -1;
-        int emptyObstacleCount = 0;
-
-        for (int i = 0; i < grid.length; i++) {
-            for (int j = 0; j < grid[i].length; j++) {
-                if (grid[i][j] == 1) {
-                    startX = i;
-                    startY = j;
-                } else if (grid[i][j] == 0) {
-                    emptyObstacleCount++;
-                }
-            }
-        }
-
-        dfsHelper(grid, startX, startY, emptyObstacleCount, 0, new boolean[grid.length][grid[0].length]);
-
-        return numOfPaths;
+  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public int uniquePathsIII(int[][] grid) {
+    if (grid.length == 0 || grid[0].length == 0) {
+      return 0;
     }
-
-    private void dfsHelper(int[][] grid,
-                           int startX,
-                           int startY,
-                           int emptyObstacleCount,
-                           int currObstacleCount,
-                           boolean[][] visited) {
-        if (startX < 0 ||
-                startX >= grid.length ||
-                startY < 0 ||
-                startY >= grid[0].length ||
-                visited[startX][startY] ||
-                grid[startX][startY] == -1) {
-            return;
+    int rows = grid.length;
+    int cols = grid[0].length;
+    int startX = 0;
+    int startY = 0;
+    int numOfEmptySquare = 0;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (grid[i][j] == 1) {
+          startX = i;
+          startY = j;
         }
-
-        if (grid[startX][startY] == 2) {
-            if (currObstacleCount == emptyObstacleCount) {
-                numOfPaths++;
-            }
-
-            return;
+        if (grid[i][j] == 0) {
+          numOfEmptySquare++;
         }
-
-        visited[startX][startY] = true;
-
-        dfsHelper(grid, startX + 1, startY, emptyObstacleCount,
-                grid[startX][startY] == 0 ? currObstacleCount + 1 : currObstacleCount, visited);
-        dfsHelper(grid, startX - 1, startY, emptyObstacleCount,
-                grid[startX][startY] == 0 ? currObstacleCount + 1 : currObstacleCount, visited);
-        dfsHelper(grid, startX, startY + 1, emptyObstacleCount,
-                grid[startX][startY] == 0 ? currObstacleCount + 1 : currObstacleCount, visited);
-        dfsHelper(grid, startX, startY - 1, emptyObstacleCount,
-                grid[startX][startY] == 0 ? currObstacleCount + 1 : currObstacleCount, visited);
-
-        visited[startX][startY] = false;
+      }
     }
+    int[] count = {0};
+    helper(grid, startX, startY, numOfEmptySquare, 0, new boolean[rows][cols], count);
+    return count[0];
+  }
+  
+  private void helper(
+    int[][] grid, int startX, int startY, int numOfEmptySquare,
+    int currEmptySquare, boolean[][] visited, int[] count
+  ) {
+    if (startX < 0 || startX >= grid.length || startY < 0 || startY >= grid[0].length || grid[startX][startY] == -1 || visited[startX][startY]) {
+      return;
+    }
+    if (grid[startX][startY] == 2) {
+      if (currEmptySquare == numOfEmptySquare) {
+        count[0]++;
+      }
+      return;
+    }
+    visited[startX][startY] = true;
+    for (int[] dir : dirs) {
+      helper(grid, startX + dir[0], startY + dir[1], numOfEmptySquare, (grid[startX][startY] == 0 ? currEmptySquare + 1 : currEmptySquare), visited, count);
+    }
+    visited[startX][startY] = false;
+  }
 }
+

From 1b90428f89eab537978295c8377dbca10e7c195c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 22 Sep 2020 11:00:13 -0500
Subject: [PATCH 0311/2175] Added one solution & modified one solution

---
 ...rt into a Sorted Circular Linked List.java | 49 ++++++++++++++++
 Medium/Majority Element II.java               | 56 +++++++++----------
 2 files changed, 77 insertions(+), 28 deletions(-)
 create mode 100644 Medium/Insert into a Sorted Circular Linked List.java

diff --git a/Medium/Insert into a Sorted Circular Linked List.java b/Medium/Insert into a Sorted Circular Linked List.java
new file mode 100644
index 00000000..f8982d5e
--- /dev/null
+++ b/Medium/Insert into a Sorted Circular Linked List.java	
@@ -0,0 +1,49 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node next;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _next) {
+        val = _val;
+        next = _next;
+    }
+};
+*/
+
+class Solution {
+  public Node insert(Node head, int insertVal) {
+    if (head == null) {
+      Node newNode = new Node(insertVal);
+      newNode.next = newNode;
+      return newNode;
+    }
+    Node prev = head;
+    Node curr = head.next;
+    boolean insert = false;
+    do {
+      if (prev.val <= insertVal && insertVal <= curr.val) {
+        insert = true;
+      } 
+      else if (prev.val > curr.val) {
+        if (insertVal >= prev.val || insertVal <= curr.val) {
+          insert = true;
+        }
+      }
+      if (insert) {
+        prev.next = new Node(insertVal, curr);
+        return head;
+      }
+      prev = curr;
+      curr = curr.next;
+    } while (prev != head);
+    prev.next = new Node(insertVal, curr);
+    return head;
+  }
+}
diff --git a/Medium/Majority Element II.java b/Medium/Majority Element II.java
index 291b6f57..4d55d74e 100644
--- a/Medium/Majority Element II.java	
+++ b/Medium/Majority Element II.java	
@@ -1,46 +1,46 @@
 class Solution {
   public List<Integer> majorityElement(int[] nums) {
-    int count1 = 0;
-    int count2 = 0;
-    Integer candidate1 = null;
-    Integer candidate2 = null;
+    int countOne = 0;
+    int countTwo = 0;
+    Integer candidateOne = null;
+    Integer candidateTwo = null;
     for (int num : nums) {
-      if (candidate1 != null && candidate1 == num) {
-        count1++; 
+      if (candidateOne != null && candidateOne == num) {
+        countOne++;
       }
-      else if (candidate2 != null && candidate2 == num) {
-        count2++;
+      else if (candidateTwo != null && candidateTwo == num) {
+        countTwo++;
       }
-      else if (count1 == 0) {
-        candidate1 = num;
-        count1 = 1;
+      else if (countOne == 0) {
+        candidateOne = num;
+        countOne = 1;
       }
-      else if (count2 == 0) {
-        candidate2 = num;
-        count2 = 1;
+      else if (countTwo == 0) {
+        candidateTwo = num;
+        countTwo = 1;
       }
       else {
-        count1--;
-        count2--;
+        countOne--;
+        countTwo--;
       }
     }
-    List<Integer> ans = new ArrayList<>();
-    count1 = 0;
-    count2 = 0;
+    List<Integer> result = new ArrayList<>();
+    countOne = 0;
+    countTwo = 0;
     for (int num : nums) {
-      if (candidate1 != null && candidate1 == num) {
-        count1++;
+      if (candidateOne != null && candidateOne == num) {
+        countOne++;
       }
-      else if (candidate2 != null && candidate2 == num) {
-        count2++;
+      else if (candidateTwo != null && candidateTwo == num) {
+        countTwo++;
       }
     }
-    if (count1 > nums.length / 3) {
-      ans.add(candidate1);
+    if (countOne > nums.length / 3) {
+      result.add(candidateOne);
     }
-    if (count2 > nums.length / 3) {
-      ans.add(candidate2);
+    if (countTwo > nums.length / 3) {
+      result.add(candidateTwo);
     }
-    return ans;
+    return result;
   }
 }

From 393653802f72dfeed9672072c97597d35f6077d6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 23 Sep 2020 08:39:27 -0500
Subject: [PATCH 0312/2175] Added Gas Station.java

---
 Medium/Gas Station.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Gas Station.java

diff --git a/Medium/Gas Station.java b/Medium/Gas Station.java
new file mode 100644
index 00000000..8208abf6
--- /dev/null
+++ b/Medium/Gas Station.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int canCompleteCircuit(int[] gas, int[] cost) {
+    int n = gas.length;
+    int tankCapacity = 0;
+    int currTankCapacity = 0;
+    int startingStation = 0;
+    for (int i = 0; i < n; i++) {
+      tankCapacity += gas[i] - cost[i];
+      currTankCapacity += gas[i] - cost[i];
+      if (currTankCapacity < 0) {
+        startingStation = i + 1;
+        currTankCapacity = 0;
+      }
+    }
+    return tankCapacity >= 0 ? startingStation : -1;
+  }
+}

From 24c59e8295a7a6b34254b0a4e0a6f3ccc95d5bbc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 25 Sep 2020 08:25:08 -0500
Subject: [PATCH 0313/2175] Added Largest Number.java

---
 Medium/Largest Number.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Medium/Largest Number.java

diff --git a/Medium/Largest Number.java b/Medium/Largest Number.java
new file mode 100644
index 00000000..4fc51c79
--- /dev/null
+++ b/Medium/Largest Number.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public String largestNumber(int[] nums) {
+    String largestNum = Arrays.stream(nums)
+        .boxed()
+        .map(String::valueOf)
+        .sorted((o1, o2) -> (o2 + o1).compareTo(o1 + o2))
+        .collect(Collectors.joining(""));
+    return largestNum.charAt(0) == '0' ? "0" : largestNum;
+  }
+}

From d47b95b20c1891c636e26bdfa87229501b54f854 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 26 Sep 2020 07:11:42 -0500
Subject: [PATCH 0314/2175] Modified Teemo Attacking.java

---
 Medium/Teemo Attacking.java | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/Medium/Teemo Attacking.java b/Medium/Teemo Attacking.java
index 3224640e..f91db3db 100644
--- a/Medium/Teemo Attacking.java	
+++ b/Medium/Teemo Attacking.java	
@@ -1,16 +1,22 @@
 class Solution {
-    public int findPoisonedDuration(int[] timeSeries, int duration) {
-        if (duration == 0 || timeSeries.length == 0) {
-            return 0;
+  public int findPoisonedDuration(int[] timeSeries, int duration) {
+    if (timeSeries.length == 0 || duration <= 0) {
+      return 0;
+    }
+    int totalTimePoisened = 0;
+    int currPoisenedTime = 0;
+    int n = timeSeries.length;
+    for (int i = 0; i < n; i++) {
+      if (currPoisenedTime > 0) {
+        if (currPoisenedTime <= timeSeries[i]) {
+          totalTimePoisened += duration;
         }
-
-        int totalTime = 0;
-        int beginTime = timeSeries[0];
-        for (int time : timeSeries) {
-            totalTime += (time < beginTime + duration ? time - beginTime : duration);
-            beginTime = time;
+        else {
+          totalTimePoisened += timeSeries[i] - timeSeries[i - 1];
         }
-        
-        return totalTime + duration;
+      }
+      currPoisenedTime = timeSeries[i] + duration;
     }
+    return totalTimePoisened + (currPoisenedTime - timeSeries[n - 1]);
+  }
 }

From 270ed55c6cc5cd6e0e0bd36cd8224aa3295f53b4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 27 Sep 2020 07:49:04 -0700
Subject: [PATCH 0315/2175] Modified Evaluate Division.java

---
 Medium/Evaluate Division.java | 65 ++++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 32 deletions(-)

diff --git a/Medium/Evaluate Division.java b/Medium/Evaluate Division.java
index 52107a1b..f4467f6e 100644
--- a/Medium/Evaluate Division.java	
+++ b/Medium/Evaluate Division.java	
@@ -1,44 +1,45 @@
 class Solution {
-  public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
-    Map<String, List<String>> map = new HashMap<>();
-    Map<String, List<Double>> valueMap = new HashMap<>();
+  public double[] calcEquation(List<List<String>> equations, double[] values,
+      List<List<String>> queries) {
+    double[] ans = new double[queries.size()];
+    Map<String, Set<String>> connectionMap = new HashMap<>();
+    Map<String, Double> valueMap = new HashMap<>();
     for (int i = 0; i < equations.size(); i++) {
-      List<String> equation = equations.get(i);
-      map.computeIfAbsent(equation.get(0), k -> new ArrayList<>()).add(equation.get(1));
-      map.computeIfAbsent(equation.get(1), k -> new ArrayList<>()).add(equation.get(0));
-      valueMap.computeIfAbsent(equation.get(0), k -> new ArrayList<>()).add(values[i]);
-      valueMap.computeIfAbsent(equation.get(1), k -> new ArrayList<>()).add(1 / values[i]);      
+      String equation = equations.get(i).get(0) + "/" + equations.get(i).get(1);
+      connectionMap.computeIfAbsent(equations.get(i).get(0), k -> new HashSet<>())
+          .add(equations.get(i).get(1));
+      connectionMap.computeIfAbsent(equations.get(i).get(1), k -> new HashSet<>())
+          .add(equations.get(i).get(0));
+      valueMap.put(equation, values[i]);
     }
-    double[] ans = new double[queries.size()];
     for (int i = 0; i < queries.size(); i++) {
-      List<String> query = queries.get(i);
-      ans[i] = dfs(map, valueMap, query.get(0), query.get(1), new HashSet<>(), 1.0);
-      ans[i] = ans[i] == 0.0 ? -1.0 : ans[i];
+      String source = queries.get(i).get(0);
+      String target = queries.get(i).get(1);
+      double[] res = {-1.0};
+      dfs(connectionMap, valueMap, source, target, new HashSet<>(), res, 1.0);
+      ans[i] = res[0];
     }
     return ans;
   }
-  
-  private double dfs(Map<String, List<String>> map, Map<String, List<Double>> valueMap, String a, String b, Set<String> set, double curr) {
-    if (set.contains(a)) {
-      return 0.0;
-    }
-    if (!map.containsKey(a)) {
-      return 0.0;
-    }
-    if (a.equals(b)) {
-      return curr;
+
+  private void dfs(Map<String, Set<String>> connectionMap, Map<String, Double> valueMap,
+      String source, String target, Set<String> visited, double[] res, double currVal) {
+    if (source.equals(target) && (
+        connectionMap.containsKey(source) || connectionMap.containsKey(target))
+    ) {
+      res[0] = currVal;
+      return;
     }
-    set.add(a);
-    List<String> children = map.get(a);
-    List<Double> valueList = valueMap.get(a);
-    double temp = 0.0;
-    for (int i = 0; i < children.size(); i++) {
-      temp = dfs(map, valueMap, children.get(i), b, set, curr * valueList.get(i));
-      if (temp != 0.0) {
-        break;
+    for (String connection : connectionMap.getOrDefault(source, new HashSet<>())) {
+      if (!visited.contains(connection)) {
+        visited.add(connection);
+        double newwCurrVal = currVal * (
+            valueMap.containsKey(source + "/" + connection) ?
+                valueMap.get(source + "/" + connection) :
+                (1 / valueMap.get(connection + "/" + source))
+        );
+        dfs(connectionMap, valueMap, connection, target, visited, res, newwCurrVal);
       }
     }
-    set.remove(a);
-    return temp;
   }
 }

From d51afaec74a743e95c0f1898205e1f95a7a96ee7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 27 Sep 2020 10:10:36 -0700
Subject: [PATCH 0316/2175] Added Crawler Log Folder.java

---
 Easy/Crawler Log Folder.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Crawler Log Folder.java

diff --git a/Easy/Crawler Log Folder.java b/Easy/Crawler Log Folder.java
new file mode 100644
index 00000000..935c1b28
--- /dev/null
+++ b/Easy/Crawler Log Folder.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int minOperations(String[] logs) {
+    int currPos = 0;
+    for (String log : logs) {
+      if (log.equals("../")) {
+        currPos -= currPos == 0 ? 0 : 1;
+      }
+      else if (!log.equals("./")) {
+        currPos++;
+      }
+    }
+    return currPos;
+  }
+}

From b62e3a89896b834f106971c763a0494b6ed6fe7a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 27 Sep 2020 17:56:02 -0700
Subject: [PATCH 0317/2175] Added Dot Product of Two Sparse Vectors.java

---
 Medium/Dot Product of Two Sparse Vectors.java | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Dot Product of Two Sparse Vectors.java

diff --git a/Medium/Dot Product of Two Sparse Vectors.java b/Medium/Dot Product of Two Sparse Vectors.java
new file mode 100644
index 00000000..92fed72b
--- /dev/null
+++ b/Medium/Dot Product of Two Sparse Vectors.java	
@@ -0,0 +1,42 @@
+class SparseVector {
+  Map<Integer, Integer> map;
+  int[] nums;
+  SparseVector(int[] nums) {
+    this.nums = nums;
+  }
+  
+  private Map<Integer, Integer> getMap() {
+    if (map != null) {
+      return map;
+    }
+    map = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] != 0) {
+        map.put(i, nums[i]);
+      }
+    }
+    return map;
+  }
+
+  // Return the dotProduct of two sparse vectors
+  public int dotProduct(SparseVector vec) {
+    Map<Integer, Integer> vecMap = vec.getMap();
+    Map<Integer, Integer> map = getMap();
+    return map.size() > vecMap.size() ? helper(vecMap, map) : helper(map, vecMap);
+  }
+  
+  private int helper(Map<Integer, Integer> map1, Map<Integer, Integer> map2) {
+    int val = 0;
+    for (Integer key : map1.keySet()) {
+      if (map2.containsKey(key)) {
+        val += map1.get(key) * map2.get(key);
+      }
+    }
+    return val;
+  }
+}
+
+// Your SparseVector object will be instantiated and called as such:
+// SparseVector v1 = new SparseVector(nums1);
+// SparseVector v2 = new SparseVector(nums2);
+// int ans = v1.dotProduct(v2);

From 9c70403ece790ffee037edfa6b071dc96abaad9a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 28 Sep 2020 06:28:45 -0700
Subject: [PATCH 0318/2175] Modified Subarray Product Less Than K.java

---
 Medium/Subarray Product Less Than K.java | 27 +++++++++++++-----------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/Medium/Subarray Product Less Than K.java b/Medium/Subarray Product Less Than K.java
index abe4415d..68ba3e13 100644
--- a/Medium/Subarray Product Less Than K.java	
+++ b/Medium/Subarray Product Less Than K.java	
@@ -1,15 +1,18 @@
 class Solution {
-    public int numSubarrayProductLessThanK(int[] nums, int k) {
-        if (k<2) return 0;
-        int result = 0;
-        int product = 1;
-        for (int i = 0, right = 0; right < nums.length; right++) {
-            product *= nums[right];
-            while (i < nums.length && product >= k) {
-                product /= nums[i++];
-            }
-            result += right - i + 1;
-        }
-        return result;
+  public int numSubarrayProductLessThanK(int[] nums, int k) {
+    if (k <= 1) {
+      return 0;
     }
+    int prod = 1;
+    int ans = 0;
+    int left = 0;
+    for (int right = 0; right < nums.length; right++) {
+      prod *= nums[right];
+      while (prod >= k) {
+        prod /= nums[left++];
+      }
+      ans += right - left + 1;
+    }
+    return ans;
+  }
 }

From 8760dcc9057732019349c57bc6870a1cc2c38521 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 30 Sep 2020 06:09:23 -0700
Subject: [PATCH 0319/2175] Modified First Missing Positive.java

---
 Hard/First Missing Positive.java | 54 ++++++++++++++------------------
 1 file changed, 24 insertions(+), 30 deletions(-)

diff --git a/Hard/First Missing Positive.java b/Hard/First Missing Positive.java
index f08d2e95..91b5b6fd 100644
--- a/Hard/First Missing Positive.java	
+++ b/Hard/First Missing Positive.java	
@@ -1,34 +1,28 @@
 class Solution {
-    public int firstMissingPositive(int[] nums) {
-        int i = 0;
-        int n = nums.length;
-        while (i < n) {
-            // If in range 0..n & not in correct index then swap
-            if (nums[i] >= 0 && nums[i] < n && nums[nums[i]] != nums[i]) {
-                swap(nums, i, nums[i]);
-            }
-            else {
-                i++;
-            }
-        }
-
-        int k = 1;
-        // Keep incrementing until the values are its correct position
-        while (k < n && nums[k] == k) {
-            k++;
-        }
-
-        // If empty array or k breaks between the end of the array
-        if (n == 0 || k < n) {
-            return k;
-        }
-        
-        return nums[0] == k ? k + 1 : k;
+  public int firstMissingPositive(int[] nums) {
+    int n = nums.length;
+    int idx = 0;
+    while (idx < n) {
+      if (nums[idx] > 0 && nums[idx] < n && nums[nums[idx]] != nums[idx]) {
+        swap(nums, idx, nums[idx]);
+      }
+      else {
+        idx++;
+      }
     }
-
-    private void swap (int[] nums, int i, int num) {
-        int temp = nums[i];
-        nums[i] = nums[num];
-        nums[num] = temp;
+    idx = 1;
+    while (idx < n && nums[idx] == idx) {
+      idx++;
     }
+    if (n == 0 || idx < n) {
+      return idx;
+    }
+    return nums[0] == idx ? idx + 1 : idx;
+  }
+  
+  private void swap(int[] nums, int i, int j) {
+    int temp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = temp;
+  }
 }

From 3f191476f68c683f5a8b4c32c34dd3f83bf70c3e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 30 Sep 2020 19:31:13 -0700
Subject: [PATCH 0320/2175] Added Find Nearest Right Node in Binary Tree.java

---
 ...ind Nearest Right Node in Binary Tree.java | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 Medium/Find Nearest Right Node in Binary Tree.java

diff --git a/Medium/Find Nearest Right Node in Binary Tree.java b/Medium/Find Nearest Right Node in Binary Tree.java
new file mode 100644
index 00000000..0388eddd
--- /dev/null
+++ b/Medium/Find Nearest Right Node in Binary Tree.java	
@@ -0,0 +1,47 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode findNeartestRightNode(TreeNode root, TreeNode u) {
+    if (root == null) {
+      return null;
+    }
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    boolean found = false;
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        if (found) {
+          return removed;
+        }
+        if (removed == u) {
+          found = true;
+        }
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+      if (found) {
+        break;
+      }
+    }
+    return null;
+  }
+}

From c6c91f728ffed171eaf4aa5c1971eac53e98540b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 1 Oct 2020 07:01:46 -0700
Subject: [PATCH 0321/2175] Added Number of Recent Calls.java

---
 Easy/Number of Recent Calls.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Number of Recent Calls.java

diff --git a/Easy/Number of Recent Calls.java b/Easy/Number of Recent Calls.java
new file mode 100644
index 00000000..230dc7be
--- /dev/null
+++ b/Easy/Number of Recent Calls.java	
@@ -0,0 +1,22 @@
+class RecentCounter {
+  Queue<Integer> queue;
+  int limit;
+  public RecentCounter() {
+    queue = new LinkedList<>();
+    limit = 3000;
+  }
+
+  public int ping(int t) {
+    queue.add(t);
+    while (!queue.isEmpty() && ((t - queue.peek()) > limit)) {
+      queue.remove();
+    }
+    return queue.size();
+  }
+}
+
+/**
+ * Your RecentCounter object will be instantiated and called as such:
+ * RecentCounter obj = new RecentCounter();
+ * int param_1 = obj.ping(t);
+ */

From 7d00750e424d8201fcfe3695ec877b889b44079b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 2 Oct 2020 12:42:48 -0700
Subject: [PATCH 0322/2175] Modified Combination Sum.java

---
 Medium/Combination Sum.java | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Medium/Combination Sum.java b/Medium/Combination Sum.java
index 4496b970..6bd7aa66 100644
--- a/Medium/Combination Sum.java	
+++ b/Medium/Combination Sum.java	
@@ -1,24 +1,24 @@
 class Solution {
-  List<List<Integer>> list;
   public List<List<Integer>> combinationSum(int[] candidates, int target) {
-    list = new ArrayList<>();
-    helper(candidates, 0, target, 0, new ArrayList<>());
-    return list;
+    List<List<Integer>> ans = new ArrayList<>();
+    helper(candidates, 0, ans, new ArrayList<>(), target);
+    return ans;
   }
   
-  private void helper(int[] candidates, int idx, int target, int currSum, List<Integer> temp) {
-    if (currSum == target) {
-      list.add(new ArrayList<>(temp));
+  private void helper(
+    int[] candidates, int idx, List<List<Integer>> ans, List<Integer> list, int target
+  ) {
+    if (target == 0) {
+      ans.add(new ArrayList<>(list));
+      return;
     }
-    else if (idx == candidates.length || currSum > target) {
+    if (target < 0 || idx == candidates.length) {
       return;
     }
-    else {
-      for (int i = idx; i < candidates.length; i++) {
-        temp.add(candidates[i]);
-        helper(candidates, i, target, currSum + candidates[i], temp);
-        temp.remove(temp.size() - 1);
-      }
+    for (int i = idx; i < candidates.length; i++) {
+      list.add(candidates[i]);
+      helper(candidates, i, ans, list, target - candidates[i]);
+      list.remove(list.size() - 1);
     }
   }
 }

From ac74fbdb3d338d7939bbd2129949992b0bde58ff Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 3 Oct 2020 10:56:05 -0700
Subject: [PATCH 0323/2175] Added 2 solutions

---
 Easy/Design Parking System.java               | 20 +++++++++++++++++
 ...ee or More Times in a One Hour Period.java | 22 +++++++++++++++++++
 2 files changed, 42 insertions(+)
 create mode 100644 Easy/Design Parking System.java
 create mode 100644 Medium/Alert Using Same Key-Card Three or More Times in a One Hour Period.java

diff --git a/Easy/Design Parking System.java b/Easy/Design Parking System.java
new file mode 100644
index 00000000..6aa29a71
--- /dev/null
+++ b/Easy/Design Parking System.java	
@@ -0,0 +1,20 @@
+class ParkingSystem {
+  int[] slots;
+  public ParkingSystem(int big, int medium, int small) {
+    slots = new int[]{big, medium, small};
+  }
+
+  public boolean addCar(int carType) {
+    if (slots[carType - 1] == 0) {
+      return false;
+    }
+    slots[carType - 1]--;
+    return true;
+  }
+}
+
+/**
+ * Your ParkingSystem object will be instantiated and called as such:
+ * ParkingSystem obj = new ParkingSystem(big, medium, small);
+ * boolean param_1 = obj.addCar(carType);
+ */
diff --git a/Medium/Alert Using Same Key-Card Three or More Times in a One Hour Period.java b/Medium/Alert Using Same Key-Card Three or More Times in a One Hour Period.java
new file mode 100644
index 00000000..604c8bfd
--- /dev/null
+++ b/Medium/Alert Using Same Key-Card Three or More Times in a One Hour Period.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public List<String> alertNames(String[] keyName, String[] keyTime) {
+    Map<String, List<Integer>> map = new HashMap<>();
+    for (int i = 0; i < keyName.length; i++) {
+      int numOfMinutes = Integer.parseInt(keyTime[i].split(":")[0]) * 60 + Integer.parseInt(keyTime[i].split(":")[1]);
+      map.computeIfAbsent(keyName[i], k -> new ArrayList<>()).add(numOfMinutes);
+    }
+    List<String> ans = new ArrayList<>();
+    for (String key : map.keySet()) {
+      List<Integer> list = map.get(key);
+      Collections.sort(list);
+      for (int i = 0; i < list.size() - 2; i++) {
+        if (list.get(i + 1) <= (list.get(i) + 60) && list.get(i + 2) <= (list.get(i) + 60)) {
+          ans.add(key);
+          break;
+        }
+      }
+    }
+    Collections.sort(ans);
+    return ans;
+  }
+}

From 2519e6ac234e92599b17985eb68078bb03868b5c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 3 Oct 2020 10:59:37 -0700
Subject: [PATCH 0324/2175] Updated README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 41ee21a2..6c48b169 100644
--- a/README.md
+++ b/README.md
@@ -2,5 +2,5 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 700+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 750+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)

From 9bca5e191528c06e4762ed0658d571c9daa15aef Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Oct 2020 06:03:34 -0700
Subject: [PATCH 0325/2175] Added Even Odd Tree.java

---
 Medium/Even Odd Tree.java | 49 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 Medium/Even Odd Tree.java

diff --git a/Medium/Even Odd Tree.java b/Medium/Even Odd Tree.java
new file mode 100644
index 00000000..0d3a4886
--- /dev/null
+++ b/Medium/Even Odd Tree.java	
@@ -0,0 +1,49 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public boolean isEvenOddTree(TreeNode root) {
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    int remainderExpected = 1;
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      Integer prev = null;
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        if (removed.val % 2 != remainderExpected) {
+          return false;
+        }
+        if (prev != null) {
+          if (remainderExpected == 1 && removed.val <= prev) {
+            return false;
+          } 
+          if (remainderExpected == 0 && removed.val >= prev) {
+            return false;
+          } 
+        }
+        prev = removed.val;
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+      remainderExpected = remainderExpected == 1 ? 0 : 1;
+    }
+    return true;
+  }
+}

From bf97f947a5396cf9f61708b2c989b6f221250f68 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Oct 2020 07:16:13 -0700
Subject: [PATCH 0326/2175] Added Special Array With X Elements Greater Than or
 Equal X.java

---
 ...ith X Elements Greater Than or Equal X.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Special Array With X Elements Greater Than or Equal X.java

diff --git a/Easy/Special Array With X Elements Greater Than or Equal X.java b/Easy/Special Array With X Elements Greater Than or Equal X.java
new file mode 100644
index 00000000..f7b4e806
--- /dev/null
+++ b/Easy/Special Array With X Elements Greater Than or Equal X.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int specialArray(int[] nums) {
+    Arrays.sort(nums);
+    int n = nums.length;
+    for (int i = n - 1; i >= 0; i--) {
+      while (i > 0 && nums[i] == nums[i - 1]) {
+        i--;
+      }
+      if (i > 0 && n - i > nums[i - 1] && n - i <= nums[i]) {
+        return n - i;
+      }
+    }
+    if(n == nums[0] || nums[0] > 0 && nums[0] - 1 == n) {
+      return n;
+    }
+    return -1;
+  }
+}

From 4dc4083e07b462602ebddc821bb01797abd377a1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Oct 2020 07:20:27 -0700
Subject: [PATCH 0327/2175] Modified Special Array With X Elements Greater Than
 or Equal X.java

---
 ...ith X Elements Greater Than or Equal X.java | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/Easy/Special Array With X Elements Greater Than or Equal X.java b/Easy/Special Array With X Elements Greater Than or Equal X.java
index f7b4e806..58ed1735 100644
--- a/Easy/Special Array With X Elements Greater Than or Equal X.java	
+++ b/Easy/Special Array With X Elements Greater Than or Equal X.java	
@@ -1,17 +1,15 @@
 class Solution {
   public int specialArray(int[] nums) {
-    Arrays.sort(nums);
+    int[] count = new int[1001];
+    for (int num : nums) {
+      count[num]++;
+    }
     int n = nums.length;
-    for (int i = n - 1; i >= 0; i--) {
-      while (i > 0 && nums[i] == nums[i - 1]) {
-        i--;
-      }
-      if (i > 0 && n - i > nums[i - 1] && n - i <= nums[i]) {
-        return n - i;
+    for (int i = 0; i < 1001; i++) {
+      if (n == i) {
+        return i;
       }
-    }
-    if(n == nums[0] || nums[0] > 0 && nums[0] - 1 == n) {
-      return n;
+      n -= count[i];
     }
     return -1;
   }

From e73e86c4799d8eb7ba3f4a5e4a242a486de40df4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Oct 2020 07:30:34 -0700
Subject: [PATCH 0328/2175] Modified Remove Covered Intervals.java

---
 Medium/Remove Covered Intervals.java | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/Medium/Remove Covered Intervals.java b/Medium/Remove Covered Intervals.java
index edb33e1d..3adf6ca3 100644
--- a/Medium/Remove Covered Intervals.java	
+++ b/Medium/Remove Covered Intervals.java	
@@ -1,25 +1,24 @@
 class Solution {
   public int removeCoveredIntervals(int[][] intervals) {
-    Arrays.sort(intervals, new Comparator<int[]>(){
-      public int compare(int[] i1, int[] i2) {
-        int c = i2[1] - i1[1];
-        if (c != 0) {
-          return c;
-        }
-        return i1[0] - i2[0];
+    Arrays.sort(intervals, (o1, o2) -> {
+      int c = o1[0] - o2[0];
+      if (c != 0) {
+        return c;
       }
+      return o2[1] - o1[1];
     });
-    int idx = 0;
     int count = 0;
-    while (idx < intervals.length) {
-      int[] currInterval = intervals[idx];
+    int idx = 0;
+    int n = intervals.length;
+    while (idx < n) {
+      int start = intervals[idx][0];
+      int end = intervals[idx][1];
       idx++;
-      while (idx < intervals.length && intervals[idx][0] >= currInterval[0] && intervals[idx][1] <= currInterval[1]
-      ) {
-        count++;
+      while (idx < n && intervals[idx][1] <= end) {
         idx++;
       }
+      count++;
     }
-    return intervals.length - count;
+    return count;
   }
 }

From 9a592faf4758b4dcf60d5c44224235850624e50f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 5 Oct 2020 05:51:12 -0700
Subject: [PATCH 0329/2175] Modified Complement of Base 10 Integer.java

---
 Easy/Complement of Base 10 Integer.java | 39 +++++++------------------
 1 file changed, 11 insertions(+), 28 deletions(-)

diff --git a/Easy/Complement of Base 10 Integer.java b/Easy/Complement of Base 10 Integer.java
index f4b73786..5bf5695d 100644
--- a/Easy/Complement of Base 10 Integer.java	
+++ b/Easy/Complement of Base 10 Integer.java	
@@ -1,32 +1,15 @@
 class Solution {
-    public int bitwiseComplement(int N) {
-        String binaryString = getInvertedBinaryString(N);
-        return getDecimalVal(binaryString);
+  public int bitwiseComplement(int N) {
+    if (N == 0) {
+      return 1;
     }
-    
-    private String getInvertedBinaryString(int n) {
-        if (n == 0) {
-            return "1";
-        }
-        
-        StringBuilder sb = new StringBuilder();
-        while (n > 0) {
-            sb.append(n % 2 == 0 ? 1 : 0);
-            n /= 2;
-        }
-        
-        return sb.reverse().toString();
-    }
-    
-    private int getDecimalVal(String s) {
-        int pow = 0;
-        int sum = 0;
-        
-        for (int i = s.length() - 1; i >= 0; i--) {
-            sum += Math.pow(2, pow) * Character.getNumericValue(s.charAt(i));
-            pow++;
-        }
-        
-        return sum;
+    int todo = N;
+    int bit = 1;
+    while (todo != 0) {
+      N = N ^ bit;
+      bit = bit << 1;
+      todo = todo >> 1;
     }
+    return N;
+  }
 }

From f62b89a10801533a7b2aee72511c0d155164db7e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 5 Oct 2020 16:48:18 -0700
Subject: [PATCH 0330/2175] Added Two Sum BSTs.java & modified 1 solution

---
 Easy/Rank Transform of an Array.java | 22 ++++++------
 Medium/Two Sum BSTs.java             | 50 ++++++++++++++++++++++++++++
 2 files changed, 60 insertions(+), 12 deletions(-)
 create mode 100644 Medium/Two Sum BSTs.java

diff --git a/Easy/Rank Transform of an Array.java b/Easy/Rank Transform of an Array.java
index 9d6c0629..951115ae 100644
--- a/Easy/Rank Transform of an Array.java	
+++ b/Easy/Rank Transform of an Array.java	
@@ -1,22 +1,20 @@
 class Solution {
   public int[] arrayRankTransform(int[] arr) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>();
-    Map<Integer, Integer> map = new HashMap<>();
+    PriorityQueue<Integer> pq = Arrays.stream(arr).boxed()
+        .collect(Collectors.toCollection(PriorityQueue::new));
     int rank = 1;
-    for (int num : arr) {
-      pq.add(num);
-    }
+    Map<Integer, Integer> rankMap = new HashMap<>();
     while (!pq.isEmpty()) {
-      int num = pq.poll();
-      if (!map.containsKey(num)) {
-        map.put(num, rank);
-        rank++;
+      int key = pq.poll();
+      rankMap.put(key, rank++);
+      while (!pq.isEmpty() && pq.peek() == key) {
+        pq.poll();
       }
     }
-    int[] rankArr = new int[arr.length];
+    int[] ans = new int[arr.length];
     for (int i = 0; i < arr.length; i++) {
-      rankArr[i] = map.get(arr[i]);
+      ans[i] = rankMap.get(arr[i]);
     }
-    return rankArr;
+    return ans;
   }
 }
diff --git a/Medium/Two Sum BSTs.java b/Medium/Two Sum BSTs.java
new file mode 100644
index 00000000..1a796d58
--- /dev/null
+++ b/Medium/Two Sum BSTs.java	
@@ -0,0 +1,50 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public boolean twoSumBSTs(TreeNode root1, TreeNode root2, int target) {
+    if (root1 == null || root2 == null) {
+      return false;
+    }
+    Set<Integer> set = new HashSet<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root2);
+    while (!queue.isEmpty()) {
+      TreeNode removed = queue.remove();
+      set.add(removed.val);
+      if (removed.left != null) {
+        queue.add(removed.left);
+      }
+      if (removed.right != null) {
+        queue.add(removed.right);
+      }
+    }
+    queue = new LinkedList<>();
+    queue.add(root1);
+    while (!queue.isEmpty()) {
+      TreeNode removed = queue.remove();
+      if (set.contains(target - removed.val)) {
+        return true;
+      }
+      if (removed.left != null) {
+        queue.add(removed.left);
+      }
+      if (removed.right != null) {
+        queue.add(removed.right);
+      }
+    }
+    return false;
+  }
+}

From 497241bd81a2ad0abbd491ee870fd4e596807929 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 6 Oct 2020 06:14:22 -0700
Subject: [PATCH 0331/2175] Added 1 solution & modified 2 solutions

---
 ...Sort Integers by The Number of 1 Bits.java | 24 ++++---------
 ...pacity To Ship Packages Within D Days.java | 29 ++++++++++++++++
 Medium/Insert into a Binary Search Tree.java  | 34 ++++++++++---------
 3 files changed, 53 insertions(+), 34 deletions(-)
 create mode 100644 Medium/Capacity To Ship Packages Within D Days.java

diff --git a/Easy/Sort Integers by The Number of 1 Bits.java b/Easy/Sort Integers by The Number of 1 Bits.java
index 47e3fb6e..d2fc14c3 100644
--- a/Easy/Sort Integers by The Number of 1 Bits.java	
+++ b/Easy/Sort Integers by The Number of 1 Bits.java	
@@ -1,22 +1,10 @@
 class Solution {
   public int[] sortByBits(int[] arr) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
-      public int compare(Integer o1, Integer o2) {
-        int c = Integer.bitCount(o1) - Integer.bitCount(o2);
-        if (c != 0) {
-          return c;
-        }
-        return o1 - o2;
-      }
-    });
-    for (int num : arr) {
-      pq.add(num);
-    }
-    int[] ans = new int[arr.length];
-    int idx = 0;
-    while (!pq.isEmpty()) {
-      ans[idx++] = pq.poll();
-    }
-    return ans;
+    return Arrays.stream(arr).boxed()
+        .sorted(Comparator.comparingInt(Integer::bitCount).thenComparingInt(o -> o))
+        .collect(Collectors.toList())
+        .stream()
+        .mapToInt(Integer::intValue)
+        .toArray();
   }
 }
diff --git a/Medium/Capacity To Ship Packages Within D Days.java b/Medium/Capacity To Ship Packages Within D Days.java
new file mode 100644
index 00000000..8b3b587f
--- /dev/null
+++ b/Medium/Capacity To Ship Packages Within D Days.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int shipWithinDays(int[] weights, int D) {
+    int maxWeight = weights[0];
+    int totalWeight = 0;
+    for (int weight : weights) {
+      maxWeight = Math.max(maxWeight, weight);
+      totalWeight += weight;
+    }
+    while (maxWeight < totalWeight) {
+      int midWeight = (maxWeight + totalWeight) / 2;
+      int need = 1;
+      int curr = 0;
+      for (int weight : weights) {
+        if (curr + weight > midWeight) {
+            need += 1;
+            curr = 0;
+        }
+        curr += weight;
+      }
+      if (need > D) {
+        maxWeight = midWeight + 1;
+      }
+      else {
+        totalWeight = midWeight;
+      }
+    }
+    return maxWeight;
+  }
+}
diff --git a/Medium/Insert into a Binary Search Tree.java b/Medium/Insert into a Binary Search Tree.java
index 22046ec5..30e5ce41 100644
--- a/Medium/Insert into a Binary Search Tree.java	
+++ b/Medium/Insert into a Binary Search Tree.java	
@@ -4,24 +4,26 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode insertIntoBST(TreeNode root, int val) {
-        if (root == null) {
-            root = new TreeNode(val);
-            return root;
-        }
-        
-        if (root.val < val) {
-            root.right = insertIntoBST(root.right, val);
-        }
-        
-        if (root.val > val) {
-            root.left = insertIntoBST(root.left, val);
-        }
-        
-        return root;
+  public TreeNode insertIntoBST(TreeNode root, int val) {
+    if (root == null) {
+      return new TreeNode(val);
     }
+    if (root.val < val) {
+      root.right = insertIntoBST(root.right, val);
+    }
+    else {
+      root.left = insertIntoBST(root.left, val);
+    }
+    return root;
+  }
 }

From e46541fab57858f6db366f33403c04f2fd09dde2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 6 Oct 2020 13:56:41 -0700
Subject: [PATCH 0332/2175] Modified Sort Array By Parity.java

---
 Easy/Sort Array By Parity.java | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Easy/Sort Array By Parity.java b/Easy/Sort Array By Parity.java
index 9e86cbd8..c74dcae0 100644
--- a/Easy/Sort Array By Parity.java	
+++ b/Easy/Sort Array By Parity.java	
@@ -1,18 +1,15 @@
 class Solution {
   public int[] sortArrayByParity(int[] A) {
-    int start = 0;
-    int end = A.length - 1;
-    while (start < end) {
-      if (A[start] % 2 > A[end] % 2) {
-        int temp = A[start];
-        A[start] = A[end];
-        A[end] = temp;
-      }
-      if (A[start] % 2 == 0) {
-        start++;
-      }
-      if (A[end] % 2 != 0) {
-        end--;
+    int evenIdx = 0;
+    int oddIdx = A.length - 1;
+    while (evenIdx < oddIdx) {
+      if (A[evenIdx] % 2 == 0) {
+        evenIdx++;
+      } 
+      else {
+        int temp = A[evenIdx];
+        A[evenIdx] = A[oddIdx];
+        A[oddIdx--] = temp;
       }
     }
     return A;

From eb32d4c5a29a64a94a98c4860098cfcd17d06ac0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 7 Oct 2020 06:20:13 -0700
Subject: [PATCH 0333/2175] Modified Rotate List.java

---
 Medium/Rotate List.java | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/Medium/Rotate List.java b/Medium/Rotate List.java
index 1cf4bae2..a761b879 100644
--- a/Medium/Rotate List.java	
+++ b/Medium/Rotate List.java	
@@ -10,36 +10,31 @@
  */
 class Solution {
   public ListNode rotateRight(ListNode head, int k) {
-    if (head == null || head.next == null || k == 0) {
+    if (head == null || k == 0) {
       return head;
     }
+    int listSize = 0;
     ListNode curr = head;
-    // Get length of list & update the number of rotations
-    int count = 0;
     while (curr != null) {
       curr = curr.next;
-      count++;
+      listSize++;
     }
-    k %= count;
+    k = k % listSize;
     if (k == 0) {
       return head;
     }
-    // Move the pointer just before the rotation index
-    int stop = count - k;
-    int currCount = 1;
+    k = listSize - k;
     curr = head;
-    while (currCount < stop) {
-      currCount++;
+    while (k-- > 1) {
       curr = curr.next;
     }
-    ListNode nextNode = curr.next;
-    // Detach rotation part of list and append it in the beginning of list
+    ListNode newHead = curr.next;
     curr.next = null;
-    ListNode newHead = nextNode;
-    while (nextNode.next != null) {
-      nextNode = nextNode.next;
+    curr = newHead;
+    while (curr != null && curr.next != null) {
+      curr = curr.next;
     }
-    nextNode.next = head;
+    curr.next = head;
     return newHead;
   }
 }

From 1ea1960d9a9c6286de8f77d8993c192e53b17774 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 8 Oct 2020 06:09:13 -0700
Subject: [PATCH 0334/2175] Modified 2 solutions

---
 Easy/Binary Search.java                       | 14 +++--
 Easy/Two Sum III - Data Structure Design.java | 52 +++++++------------
 2 files changed, 26 insertions(+), 40 deletions(-)

diff --git a/Easy/Binary Search.java b/Easy/Binary Search.java
index 32630594..8fac5829 100644
--- a/Easy/Binary Search.java	
+++ b/Easy/Binary Search.java	
@@ -1,19 +1,17 @@
 class Solution {
   public int search(int[] nums, int target) {
-    return binarySearchImpl(nums, 0, nums.length - 1, target);
-  }
-  
-  private int binarySearchImpl(int[] nums, int start, int end, int target) {
-    while (start <= end) {
-      int mid = (start + end) / 2;
+    int left = 0;
+    int right = nums.length - 1;
+    while (left <= right) {
+      int mid = (left + right) / 2;
       if (nums[mid] == target) {
         return mid;
       }
       else if (nums[mid] > target) {
-        end = mid - 1;
+        right = mid - 1;
       }
       else {
-        start = mid + 1;
+        left = mid + 1;
       }
     }
     return -1;
diff --git a/Easy/Two Sum III - Data Structure Design.java b/Easy/Two Sum III - Data Structure Design.java
index bafbfa64..84a33905 100644
--- a/Easy/Two Sum III - Data Structure Design.java	
+++ b/Easy/Two Sum III - Data Structure Design.java	
@@ -1,39 +1,27 @@
 class TwoSum {
 
-    /** Initialize your data structure here. */
-    List<Integer> list;
-    Map<Integer, Integer> map;
-    public TwoSum() {
-        list = new ArrayList<>();
-        map = new HashMap<>();
-    }
-    
-    /** Add the number to an internal data structure.. */
-    public void add(int number) {
-        if (map.containsKey(number)) {
-            map.put(number, map.get(number) + 1);
-        }
-        else {
-            map.put(number, 1);
-            list.add(number);
-        }
-    }
-    
-    /** Find if there exists any pair of numbers which sum is equal to the value. */
-    public boolean find(int value) {
-        for (int num : list) {
-            int diff = value - num;
-            if (diff != num && map.containsKey(diff)) {
-                return true;
-            }
-            
-            if (diff == num && map.get(diff) > 1) {
-                return true;
-            }
+  /** Initialize your data structure here. */
+  Map<Integer, Integer> map;
+  public TwoSum() {
+    map = new HashMap<>();
+  }
+
+  /** Add the number to an internal data structure.. */
+  public void add(int number) {
+    map.put(number, map.getOrDefault(number, 0) + 1);
+  }
+
+  /** Find if there exists any pair of numbers which sum is equal to the value. */
+  public boolean find(int value) {
+    for (Integer key : map.keySet()) {
+      if (map.containsKey(value - key)) {
+        if (value - key != key || (value - key == key && map.get(key) > 1)) {
+          return true;
         }
-        
-        return false;
+      }
     }
+    return false;
+  }
 }
 
 /**

From c4ad4c493ce2f869a5109de8390b110574470333 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 10 Oct 2020 07:52:09 -0700
Subject: [PATCH 0335/2175] Added 1 solution & modified 1 solution

---
 Easy/Reverse String.java                    |  6 ++---
 Medium/Count Submatrices With All Ones.java | 27 +++++++++++++++++++++
 2 files changed, 29 insertions(+), 4 deletions(-)
 create mode 100644 Medium/Count Submatrices With All Ones.java

diff --git a/Easy/Reverse String.java b/Easy/Reverse String.java
index 28dfed23..959b5bed 100644
--- a/Easy/Reverse String.java	
+++ b/Easy/Reverse String.java	
@@ -4,10 +4,8 @@ public void reverseString(char[] s) {
     int end = s.length - 1;
     while (start < end) {
       char temp = s[start];
-      s[start] = s[end];
-      s[end] = temp;
-      start++;
-      end--;
+      s[start++] = s[end];
+      s[end--] = temp;
     }
   }
 }
diff --git a/Medium/Count Submatrices With All Ones.java b/Medium/Count Submatrices With All Ones.java
new file mode 100644
index 00000000..d1175355
--- /dev/null
+++ b/Medium/Count Submatrices With All Ones.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public int numSubmat(int[][] mat) {
+    int m = mat.length;
+    int n = mat[0].length;
+    int res = 0;
+    for (int i = 0; i < m; i++) {
+      int[] arr = new int[n];
+      Arrays.fill(arr, 1);
+      for (int j = i; j < m; j++) {
+        for (int k = 0; k < n; k++) {
+          arr[k] &= mat[j][k];
+        }
+        res += countOneRow(arr);
+      }
+    }
+    return res;
+  }
+  
+  private int countOneRow(int[] A) {
+    int res = 0, length = 0;
+    for (int i = 0; i < A.length; ++i) {
+      length = (A[i] == 0 ? 0 : length + 1);
+      res += length;
+    }
+    return res;
+  }
+}

From 45b4123f58335f2a8477307f71e95c5b875e9c02 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 11 Oct 2020 07:42:15 -0700
Subject: [PATCH 0336/2175] Added Maximum Nesting Depth of the Parentheses.java

---
 Easy/Maximum Nesting Depth of the Parentheses.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Maximum Nesting Depth of the Parentheses.java

diff --git a/Easy/Maximum Nesting Depth of the Parentheses.java b/Easy/Maximum Nesting Depth of the Parentheses.java
new file mode 100644
index 00000000..19a50736
--- /dev/null
+++ b/Easy/Maximum Nesting Depth of the Parentheses.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int maxDepth(String s) {
+    int currCount = 0;
+    int maxCount = 0;
+    for (char c : s.toCharArray()) {
+      currCount += c == '(' ? 1 : (c == ')' ? -1 : 0);
+      maxCount = Math.max(maxCount, currCount);
+    }
+    return maxCount;
+  }
+}

From 7e5c0e4b2235d62afe688eaebb0af3fe35b30d47 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 11 Oct 2020 08:14:32 -0700
Subject: [PATCH 0337/2175] Added Maximal Network Rank.java

---
 Medium/Maximal Network Rank.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Maximal Network Rank.java

diff --git a/Medium/Maximal Network Rank.java b/Medium/Maximal Network Rank.java
new file mode 100644
index 00000000..211a7c8e
--- /dev/null
+++ b/Medium/Maximal Network Rank.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int maximalNetworkRank(int n, int[][] roads) {
+    boolean[][] connected = new boolean[n][n];
+    int[] count = new int[n];
+    for (int[] road : roads) {
+      count[road[0]]++;
+      count[road[1]]++;
+      connected[road[0]][road[1]] = true;
+      connected[road[1]][road[0]] = true;
+    }
+    int maxCount = 0;
+    for (int i = 0; i < n; i++) {
+      for (int j = i + 1; j < n; j++) {
+        maxCount = Math.max(maxCount, count[i] + count[j] - (connected[i][j] ? 1 : 0));
+      }
+    }
+    return maxCount;
+  }
+}

From 89a9a4ba27d24b985e42facbfeec84488aefee14 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 11 Oct 2020 11:43:01 -0700
Subject: [PATCH 0338/2175] Added Remove Duplicate Letters.java

---
 Medium/Remove Duplicate Letters.java | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Remove Duplicate Letters.java

diff --git a/Medium/Remove Duplicate Letters.java b/Medium/Remove Duplicate Letters.java
new file mode 100644
index 00000000..1f01908a
--- /dev/null
+++ b/Medium/Remove Duplicate Letters.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public String removeDuplicateLetters(String s) {
+    int[] counter = new int[26];
+    char[] charArray = s.toCharArray();
+    for (char c : charArray) {
+      counter[c - 'a']++;
+    }
+    boolean[] visited = new boolean[26];
+    Stack<Character> stack = new Stack<>();
+    for (Character c : charArray) {
+      int idx = c - 'a';
+      counter[idx]--;
+      if (visited[idx]) {
+        continue;
+      }
+      while (!stack.isEmpty() && c < stack.peek() && counter[stack.peek() - 'a'] > 0) {
+        visited[stack.pop() - 'a'] = false;
+      }
+      stack.push(c);
+      visited[idx] = true;
+    }
+    StringBuilder sb = new StringBuilder();
+    while (!stack.isEmpty()) {
+      sb.append(stack.pop());
+    }
+    return sb.reverse().toString();
+  }
+}

From aac6003679b2eb0be9f1333bf63d8d01ff0b4c35 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 12 Oct 2020 06:23:48 -0700
Subject: [PATCH 0339/2175] Added Minimum Number of Steps to Make Two Strings
 Anagram.java

---
 ... of Steps to Make Two Strings Anagram.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Minimum Number of Steps to Make Two Strings Anagram.java

diff --git a/Medium/Minimum Number of Steps to Make Two Strings Anagram.java b/Medium/Minimum Number of Steps to Make Two Strings Anagram.java
new file mode 100644
index 00000000..d81c4868
--- /dev/null
+++ b/Medium/Minimum Number of Steps to Make Two Strings Anagram.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int minSteps(String s, String t) {
+    int[] counterS = getFreqCounter(s);
+    int[] counterT = getFreqCounter(t);
+    int count = 0;
+    for (int i = 0; i < 26; i++) {
+      if (counterT[i] < counterS[i]) {
+        count += counterS[i] - counterT[i];
+      }
+    }
+    return count;
+  }
+  
+  private int[] getFreqCounter(String s) {
+    int[] counter = new int[26];
+    for (char c : s.toCharArray()) {
+      counter[c - 'a']++;
+    }
+    return counter;
+  }
+}

From 886c9a1c655ea262aaca2a116910569c9ed06acc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 13 Oct 2020 05:17:36 -0700
Subject: [PATCH 0340/2175] Modified Sort List.java

---
 Medium/Sort List.java | 58 +++++++++++++++++++++++++++++--------------
 1 file changed, 40 insertions(+), 18 deletions(-)

diff --git a/Medium/Sort List.java b/Medium/Sort List.java
index 8a5a9166..2e0492e6 100644
--- a/Medium/Sort List.java	
+++ b/Medium/Sort List.java	
@@ -3,26 +3,48 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode sortList(ListNode head) {
-        ArrayList<Integer> arr = new ArrayList<>();
-        ListNode curr = head;
-        while (curr != null) {
-            arr.add(curr.val);
-            curr = curr.next;
-        }
-        
-        Collections.sort(arr);
-        
-        curr = head;
-        for (int i=0;i<arr.size();i++) {
-            curr.val = arr.get(i);
-            curr = curr.next;
-        }
-        
-        return head;
+  public ListNode sortList(ListNode head) {
+    if (head == null || head.next == null) {
+      return head;
     }
+    ListNode mid = getMid(head);
+    ListNode left = sortList(head);
+    ListNode right = sortList(mid);
+    return merge(left, right);
+  }
+  
+  private ListNode getMid(ListNode head) {
+    ListNode prev = null;
+    while (head != null && head.next != null) {
+      prev = prev == null ? head : prev.next;
+      head = head.next.next;
+    }
+    ListNode mid = prev.next;
+    prev.next = null;
+    return mid;
+  }
+  
+  private ListNode merge(ListNode l1, ListNode l2) {
+    ListNode dummyHead = new ListNode();
+    ListNode tail = dummyHead;
+    while (l1 != null && l2 != null) {
+      if (l1.val < l2.val) {
+        tail.next = l1;
+        l1 = l1.next;
+      }
+      else {
+        tail.next = l2;
+        l2 = l2.next;
+      }
+      tail = tail.next;
+    }
+    tail.next = l1 != null ? l1 : l2;
+    return dummyHead.next;
+  }
 }

From acd83cb1e33ee1cfba6bbd8994f76646b68b8536 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 14 Oct 2020 06:02:27 -0700
Subject: [PATCH 0341/2175] Added House Robber II.java

---
 Medium/House Robber II.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/House Robber II.java

diff --git a/Medium/House Robber II.java b/Medium/House Robber II.java
new file mode 100644
index 00000000..5219984e
--- /dev/null
+++ b/Medium/House Robber II.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int rob(int[] nums) {
+    if (nums.length == 1) {
+      return nums[0];
+    }
+    return Math.max(robHelper(nums, 0, nums.length - 2), robHelper(nums, 1, nums.length - 1));
+  }
+  
+  private int robHelper(int[] nums, int lower, int higher) {
+    int include = 0;
+    int exclude = 0;
+    for (int j = lower; j <= higher; j++) {
+      int includeIdx = include;
+      int excludeIdx = exclude;
+      include = excludeIdx + nums[j];
+      exclude = Math.max(excludeIdx, includeIdx);
+    }
+    return Math.max(include, exclude);
+  }
+}

From 9c1ed47ef5026e2eda0bbc4714fd73b1804ba91e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 15 Oct 2020 06:10:01 -0700
Subject: [PATCH 0342/2175] Added Rotate Array.java

---
 Easy/Rotate Array.java   | 12 ------------
 Medium/Rotate Array.java | 18 ++++++++++++++++++
 2 files changed, 18 insertions(+), 12 deletions(-)
 delete mode 100644 Easy/Rotate Array.java
 create mode 100644 Medium/Rotate Array.java

diff --git a/Easy/Rotate Array.java b/Easy/Rotate Array.java
deleted file mode 100644
index 80e108e3..00000000
--- a/Easy/Rotate Array.java	
+++ /dev/null
@@ -1,12 +0,0 @@
-public class Solution {
-    public void rotate(int[] nums, int k) {
-        int[] n = new int[nums.length];
-        for (int i=0;i<nums.length;i++) {
-            n[(i+k)%nums.length] = nums[i];
-        }
-        
-        for (int i=0;i<nums.length;i++) {
-            nums[i] = n[i];
-        }
-    }
-}
\ No newline at end of file
diff --git a/Medium/Rotate Array.java b/Medium/Rotate Array.java
new file mode 100644
index 00000000..4eefa93c
--- /dev/null
+++ b/Medium/Rotate Array.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public void rotate(int[] nums, int k) {
+    k %= nums.length;
+    reverse(nums, 0, nums.length - 1);
+    reverse(nums, 0, k - 1);
+    reverse(nums, k, nums.length - 1);
+  }
+  
+  private void reverse(int[] nums, int start, int end) {
+    while (start < end) {
+      int temp = nums[start];
+      nums[start] = nums[end];
+      nums[end] = temp;
+      start++;
+      end--;
+    }
+  }
+}

From 0cc6233f1bfc007acd7b949a2e3ed5b6e7a38ffa Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 15 Oct 2020 10:59:06 -0700
Subject: [PATCH 0343/2175] Added Adding Two Negabinary Numbers.java

---
 Medium/Adding Two Negabinary Numbers.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Adding Two Negabinary Numbers.java

diff --git a/Medium/Adding Two Negabinary Numbers.java b/Medium/Adding Two Negabinary Numbers.java
new file mode 100644
index 00000000..7f371f30
--- /dev/null
+++ b/Medium/Adding Two Negabinary Numbers.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int[] addNegabinary(int[] arr1, int[] arr2) {
+    int idxOne = arr1.length - 1;
+    int idxTwo = arr2.length - 1;
+    int carry = 0;
+    Stack<Integer> stack = new Stack<>();
+    while (idxOne >= 0 || idxTwo >= 0 || carry != 0) {
+      int valOne = idxOne >= 0 ? arr1[idxOne--] : 0;
+      int valTwo = idxTwo >= 0 ? arr2[idxTwo--] : 0;
+      carry = valOne + valTwo + carry;
+      stack.push(carry & 1);
+      carry = -(carry >> 1);
+    }
+    while (!stack.isEmpty() && stack.peek() == 0) {
+      stack.pop();
+    }
+    int[] result = new int[stack.size()];
+    for (int i = 0; i < result.length; i++) {
+      result[i] = stack.pop();
+    }
+    return result.length == 0 ? new int[]{0} : result;
+  }
+}

From 6b4557d6efbbd18772ecb797d340ec8aae107a0c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 16 Oct 2020 05:56:30 -0700
Subject: [PATCH 0344/2175] Modified Search a 2D Matrix.java

---
 Medium/Search a 2D Matrix.java | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/Medium/Search a 2D Matrix.java b/Medium/Search a 2D Matrix.java
index 18236db6..bb5861eb 100644
--- a/Medium/Search a 2D Matrix.java	
+++ b/Medium/Search a 2D Matrix.java	
@@ -3,23 +3,23 @@ public boolean searchMatrix(int[][] matrix, int target) {
     if (matrix.length == 0 || matrix[0].length == 0) {
       return false;
     }
-    int i = 0;
-    int j = 0;
-    int rows = matrix.length;
-    int cols = matrix[0].length;
-    while (i < rows && j < cols) {
-      int num = matrix[i][j];
-      if (num == target) {
+    int rowIdx = matrix.length - 1;
+    int colIdx = matrix[0].length - 1;
+    while (rowIdx >= 0 && colIdx >= 0) {
+      int val = matrix[rowIdx][colIdx];
+      if (val == target) {
         return true;
       }
-      else {
-        if (i != rows - 1 && matrix[i + 1][j] <= target) {
-          i++;
-        }
-        else {
-          j++;
+      if (val >= matrix[rowIdx][0]) {
+        colIdx--;
+        if (colIdx < 0) {
+          colIdx = matrix[0].length - 1;
+          rowIdx--;
         }
       }
+      else {
+        rowIdx--;
+      }
     }
     return false;
   }

From daf09eccbc43261ac3704ca715f373712632fcb9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 16 Oct 2020 10:12:24 -0700
Subject: [PATCH 0345/2175] Added Minimum Value to Get Positive Step by Step
 Sum.java

---
 ...mum Value to Get Positive Step by Step Sum.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Minimum Value to Get Positive Step by Step Sum.java

diff --git a/Easy/Minimum Value to Get Positive Step by Step Sum.java b/Easy/Minimum Value to Get Positive Step by Step Sum.java
new file mode 100644
index 00000000..4745ae33
--- /dev/null
+++ b/Easy/Minimum Value to Get Positive Step by Step Sum.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int minStartValue(int[] nums) {
+    int startValue = 1;
+    int currSum = startValue;
+    for (int num : nums) {
+      currSum += num;
+      if (currSum < 1) {
+        startValue += 1 - currSum;
+        currSum += 1 - currSum;
+      }
+    }
+    return startValue;
+  }
+}

From 50ca650e41f9849c9a67547547658e488dc90bb8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 19 Oct 2020 08:17:09 -0500
Subject: [PATCH 0346/2175] Added Largest Substring Between Two Equal
 Characters.java

---
 ...rgest Substring Between Two Equal Characters.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Largest Substring Between Two Equal Characters.java

diff --git a/Easy/Largest Substring Between Two Equal Characters.java b/Easy/Largest Substring Between Two Equal Characters.java
new file mode 100644
index 00000000..fa0d8495
--- /dev/null
+++ b/Easy/Largest Substring Between Two Equal Characters.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int maxLengthBetweenEqualCharacters(String s) {
+    Map<Character, Integer> startIndex = new HashMap<>();
+    int largestSubstringLength = -1;
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      startIndex.putIfAbsent(c, i);
+      largestSubstringLength = Math.max(largestSubstringLength, i - startIndex.get(c) - 1);
+    }
+    return largestSubstringLength;
+  }
+}

From c48c663d702e79efb66b6d0fa707a1185376d462 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 19 Oct 2020 11:47:21 -0500
Subject: [PATCH 0347/2175] Refactored Repeated DNA Sequences.java

---
 Medium/Repeated DNA Sequences.java | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/Medium/Repeated DNA Sequences.java b/Medium/Repeated DNA Sequences.java
index ec329cfd..c764a92c 100644
--- a/Medium/Repeated DNA Sequences.java	
+++ b/Medium/Repeated DNA Sequences.java	
@@ -1,19 +1,13 @@
 class Solution {
-    public List<String> findRepeatedDnaSequences(String s) {
-        Map<String, Integer> map = new HashMap<>();
-        
-        for (int i=0; i<=s.length() - 10; i++) {
-            map.put(s.substring(i, i+10), map.getOrDefault(s.substring(i, i+10), 0) + 1);
-        }
-        
-        List<String> ans = new ArrayList<>();
-        
-        for (Map.Entry<String, Integer> entry : map.entrySet()) {
-            if (entry.getValue() > 1) {
-                ans.add(entry.getKey());
-            }
-        }
-        
-        return ans;
+  public List<String> findRepeatedDnaSequences(String s) {
+    Set<String> seenSequences = new HashSet<>();
+    Set<String> duplicateSequences = new HashSet<>();
+    for (int idx = 0; idx <= s.length() - 10; idx++) {
+      String currentSequence = s.substring(idx, idx + 10);
+      if (!seenSequences.add(currentSequence)) {
+        duplicateSequences.add(currentSequence);
+      }
     }
+    return new ArrayList<>(duplicateSequences);
+  }
 }

From 1f67e194477290e9e3cfcb4e094d71c0fba4f0ae Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 20 Oct 2020 07:09:40 -0700
Subject: [PATCH 0348/2175] Refactored Clone Graph.java

---
 Medium/Clone Graph.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Medium/Clone Graph.java b/Medium/Clone Graph.java
index 1c116288..47a4ba95 100644
--- a/Medium/Clone Graph.java	
+++ b/Medium/Clone Graph.java	
@@ -29,12 +29,12 @@ public Node cloneGraph(Node node) {
     Map<Node, Node> map = new HashMap<>();
     Queue<Node> queue = new LinkedList<>();
     queue.add(node);
-    map.put(node, new Node(node.val, new ArrayList<>()));
+    map.put(node, new Node(node.val));
     while (!queue.isEmpty()) {
       Node removed = queue.remove();
       for (Node neighbor : removed.neighbors) {
         if (!map.containsKey(neighbor)) {
-          map.put(neighbor, new Node(neighbor.val, new ArrayList<>()));
+          map.put(neighbor, new Node(neighbor.val));
           queue.add(neighbor);
         }
         map.get(removed).neighbors.add(map.get(neighbor));

From 72fc0b796e2113073d814078305f97fce2392b24 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 20 Oct 2020 07:10:06 -0700
Subject: [PATCH 0349/2175] Added Mean of Array After Removing Some
 Elements.java

---
 Easy/Mean of Array After Removing Some Elements.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Mean of Array After Removing Some Elements.java

diff --git a/Easy/Mean of Array After Removing Some Elements.java b/Easy/Mean of Array After Removing Some Elements.java
new file mode 100644
index 00000000..ef025364
--- /dev/null
+++ b/Easy/Mean of Array After Removing Some Elements.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public double trimMean(int[] arr) {
+    Arrays.sort(arr);
+    int n = arr.length;
+    double sum = 0;
+    for (int idx = n / 20; idx < n - n / 20; idx++) 
+      sum += arr[idx];
+    return sum / (n - n / 10);
+  }
+}

From 953c60aa49dfe3c45269783e813dcb731e029de8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 21 Oct 2020 05:18:21 -0700
Subject: [PATCH 0350/2175] Refactored Asteroid Collision.java

---
 Medium/Asteroid Collision.java | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/Medium/Asteroid Collision.java b/Medium/Asteroid Collision.java
index dc8ca9bf..102f3f53 100644
--- a/Medium/Asteroid Collision.java	
+++ b/Medium/Asteroid Collision.java	
@@ -2,28 +2,27 @@ class Solution {
   public int[] asteroidCollision(int[] asteroids) {
     Stack<Integer> stack = new Stack<>();
     for (int asteroid : asteroids) {
-      boolean toAdd = true;
       if (asteroid < 0) {
-        while (!stack.isEmpty() && stack.peek() > 0) {
-          if (Math.abs(asteroid) > stack.peek()) {
-            stack.pop();
-            continue;
-          }
-          else if (Math.abs(asteroid) == stack.peek()) {
+        while (!stack.isEmpty() && stack.peek() > 0 && stack.peek() < Math.abs(asteroid)) {
+          stack.pop();
+        }
+        if (!stack.isEmpty() && stack.peek() > 0) {
+          if (stack.peek() == Math.abs(asteroid)) {
             stack.pop();
           }
-          toAdd = false;
-          break;
+        }
+        else {
+          stack.push(asteroid);
         }
       }
-      if (toAdd) {
+      else {
         stack.push(asteroid);
       }
     }
-    int[] ans = new int[stack.size()];
-    for (int i = ans.length - 1; i >= 0; i--) {
-      ans[i] = stack.pop();
+    int[] state = new int[stack.size()];
+    for (int i = state.length - 1; i >= 0; i--) {
+      state[i] = stack.pop();
     }
-    return ans;
+    return state;
   }
 }

From 56791afef96a6c2ab8baa5e6c2de4541ded96536 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 21 Oct 2020 05:37:29 -0700
Subject: [PATCH 0351/2175] Refactored Relative Ranks.java

---
 Easy/Relative ranks.java | 52 +++++++++++++++-------------------------
 1 file changed, 19 insertions(+), 33 deletions(-)

diff --git a/Easy/Relative ranks.java b/Easy/Relative ranks.java
index 211226ea..94e12902 100644
--- a/Easy/Relative ranks.java	
+++ b/Easy/Relative ranks.java	
@@ -1,34 +1,20 @@
-import java.util.Arrays;
-
-public class Solution {
-    public String[] findRelativeRanks(int[] nums) {
-        int[] nums_copy = nums.clone();
-        Arrays.sort(nums);
-        for (int i = 0; i < nums.length / 2; i++) {
-            int temp = nums[i];
-            nums[i] = nums[nums.length - 1 - i];
-            nums[nums.length - 1 - i] = temp;
-        }
-
-        String[] rank = {"Gold Medal", "Silver Medal", "Bronze Medal"};
-
-        String[] ans = new String[nums.length];
-        for (int i=0;i<nums.length;i++) {
-            if (findIndex(nums,nums_copy[i]) == 0 || findIndex(nums,nums_copy[i]) == 1 || findIndex(nums,nums_copy[i]) == 2) {
-                ans[i] = rank[findIndex(nums,nums_copy[i])];
-            }
-            else {
-                ans[i] = String.valueOf(findIndex(nums,nums_copy[i]) + 1);
-            }
-        }
-        return ans;
+class Solution {
+  public String[] findRelativeRanks(int[] nums) {
+    PriorityQueue<Integer> orderedRanking = new PriorityQueue<>((o1, o2) -> nums[o2] - nums[o1]);
+    orderedRanking.addAll(IntStream.range(0, nums.length).boxed().collect(Collectors.toList()));
+    String[] relativeRanks = new String[nums.length];
+    int currentRank = 1;
+    while (!orderedRanking.isEmpty()) {
+      int removed = orderedRanking.poll();
+      if (currentRank > 3) {
+        relativeRanks[removed] = String.valueOf(currentRank++);
+      } else {
+        relativeRanks[removed] = (
+            currentRank == 1 ? "Gold Medal" : (currentRank == 2 ? "Silver Medal" : "Bronze Medal")
+        );
+        currentRank++;
+      }
     }
-    public int findIndex(int[] nums, int elem) {
-        for (int i=0;i<nums.length;i++) {
-            if (nums[i] == elem) {
-                return i;
-            }
-        }
-        return -1;
-    }
-}
\ No newline at end of file
+    return relativeRanks;
+  }
+}

From 6e0b577c6ea5445d188111e4b623074605ce2b57 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 22 Oct 2020 12:32:49 -0700
Subject: [PATCH 0352/2175] Refactored Count Binary Substrings.java

---
 Easy/Count Binary Substrings.java | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/Easy/Count Binary Substrings.java b/Easy/Count Binary Substrings.java
index fec040fe..ff2ee4b0 100644
--- a/Easy/Count Binary Substrings.java	
+++ b/Easy/Count Binary Substrings.java	
@@ -1,17 +1,19 @@
 class Solution {
-    public int countBinarySubstrings(String s) {
-        int prev = 0;
-        int curr = 1; 
-        int res = 0;
-        
-        for (int i=1;i<s.length();i++) {
-            if (s.charAt(i) == s.charAt(i-1)) curr++;
-            else {
-                prev = curr;
-                curr = 1;
-            }
-            if (prev >= curr) res++;
-        }
-        return res;
+  public int countBinarySubstrings(String s) {
+    int currValueCount = 1;
+    int prevValueCount = 0;
+    int count = 0;
+    for (int i = 1; i < s.length(); i++) {
+      if (s.charAt(i) == s.charAt(i - 1)) {
+        currValueCount++;
+      } else {
+        prevValueCount = currValueCount;
+        currValueCount = 1;
+      }
+      if (prevValueCount >= currValueCount) {
+        count++;
+      }
     }
+    return count;
+  }
 }

From a6e115afa3e57344ceb945abfd56b8fc58c96d30 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 23 Oct 2020 07:46:46 -0700
Subject: [PATCH 0353/2175] Refactored 132 Pattern.java

---
 Medium/132 Pattern.java | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/Medium/132 Pattern.java b/Medium/132 Pattern.java
index 33d16450..80a6c64e 100644
--- a/Medium/132 Pattern.java	
+++ b/Medium/132 Pattern.java	
@@ -3,21 +3,21 @@ public boolean find132pattern(int[] nums) {
     if (nums.length < 3) {
       return false;
     }
-    Stack<Integer> stack = new Stack<>();
-    int[] min = new int[nums.length];
-    min[0] = nums[0];
-    for (int i = 1; i < nums.length; i++) {
-      min[i] = Math.min(min[i - 1], nums[i]);
+    int[] minTillIndex = new int[nums.length];
+    minTillIndex[0] = nums[0];
+    for (int idx = 1; idx < nums.length; idx++) {
+      minTillIndex[idx] = Math.min(minTillIndex[idx - 1], nums[idx]);
     }
-    for (int i = nums.length - 1; i >= 0; i--) {
-      if (nums[i] > min[i]) {  // Consider nums[i] as 3 and min[i] as 1
-        while (!stack.isEmpty() && stack.peek() <= min[i]) {  // Search for 2  
+    Stack<Integer> stack = new Stack<>();
+    for (int idx = nums.length - 1; idx >= 0; idx--) {
+      if (nums[idx] > minTillIndex[idx]) {
+        while (!stack.isEmpty() && stack.peek() <= minTillIndex[idx]) {
           stack.pop();
         }
-        if (!stack.isEmpty() && stack.peek() < nums[i]) {  // If 2 found
+        if (!stack.isEmpty() && stack.peek() < nums[idx]) {
           return true;
         }
-        stack.push(nums[i]);
+        stack.push(nums[idx]);
       }
     }
     return false;

From 0a060586a25614038b8e341adf8fc3e4e9c46e56 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 25 Oct 2020 08:21:54 -0700
Subject: [PATCH 0354/2175] Added Slowest Key.java

---
 Easy/Slowest Key.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Slowest Key.java

diff --git a/Easy/Slowest Key.java b/Easy/Slowest Key.java
new file mode 100644
index 00000000..958b8b42
--- /dev/null
+++ b/Easy/Slowest Key.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public char slowestKey(int[] releaseTimes, String keysPressed) {
+    int maxReleaseTime = 0;
+    int maxReleaseTimeIdx = 0;
+    for (int idx = 0; idx < releaseTimes.length; idx++) {
+      int currentIdx = keysPressed.charAt(idx) - 'a';
+      int currReleaseTime = releaseTimes[idx] - (idx == 0 ? 0 : releaseTimes[idx - 1]);
+      if (currReleaseTime >= maxReleaseTime) {
+        if (currReleaseTime > maxReleaseTime)  {
+          maxReleaseTimeIdx = currentIdx;
+        } else if (currentIdx > maxReleaseTimeIdx) {
+          maxReleaseTimeIdx = currentIdx;
+        }
+        maxReleaseTime = currReleaseTime;
+      }
+    }
+    return (char) (97 + maxReleaseTimeIdx);
+  }
+}

From 156aad2e0fb598b25571190cb51937fda36e0bf3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 25 Oct 2020 19:02:27 -0700
Subject: [PATCH 0355/2175] Added Arithmetic Subarrays.java

---
 Medium/Arithmetic Subarrays.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Arithmetic Subarrays.java

diff --git a/Medium/Arithmetic Subarrays.java b/Medium/Arithmetic Subarrays.java
new file mode 100644
index 00000000..ae79bb2a
--- /dev/null
+++ b/Medium/Arithmetic Subarrays.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public List<Boolean> checkArithmeticSubarrays(int[] nums, int[] l, int[] r) {
+    List<Boolean> queryResult = new ArrayList<>();
+    for (int idx = 0; idx < l.length; idx++) {
+      queryResult.add(isArithmeticProgressionPossible(nums, l[idx], r[idx]));
+    }
+    return queryResult;
+  }
+  
+  private boolean isArithmeticProgressionPossible(int[] nums, int startIdx, int endIdx) {
+    List<Integer> sequence = new ArrayList<>();
+    for (int idx = startIdx; idx <= endIdx; idx++) {
+      sequence.add(nums[idx]);
+    }
+    Collections.sort(sequence);
+    Integer diff = sequence.get(1) - sequence.get(0);
+    for (int idx = 2; idx < sequence.size(); idx++) {
+      if (diff != (sequence.get(idx) - sequence.get(idx - 1))) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

From 8f621afc05b2db153284f069fa01d0b2f319897d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 26 Oct 2020 06:49:26 -0700
Subject: [PATCH 0356/2175] Added Champagne Tower.java

---
 Medium/Champagne Tower.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Champagne Tower.java

diff --git a/Medium/Champagne Tower.java b/Medium/Champagne Tower.java
new file mode 100644
index 00000000..b8f0797e
--- /dev/null
+++ b/Medium/Champagne Tower.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public double champagneTower(int poured, int query_row, int query_glass) {
+    double[][] glassCapacity = new double[query_row + 1][query_glass + 2];
+    glassCapacity[0][0] = poured;
+    for (int currRow = 0; currRow < query_row; currRow++) {
+      for (int currCol = 0; currCol <= query_glass; currCol++) {
+        double currCapacity = Math.max(glassCapacity[currRow][currCol] - 1.0, 0);
+        glassCapacity[currRow + 1][currCol] += currCapacity / 2.0;
+        glassCapacity[currRow + 1][currCol + 1] += currCapacity / 2.0;
+      }
+    }
+    return Math.min(glassCapacity[query_row][query_glass], 1.0);
+  } 
+}

From fb2a29249d9ba28b42ac2de567af3929d127605b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 26 Oct 2020 16:13:51 -0700
Subject: [PATCH 0357/2175] Refactored Set Mismatch.java

---
 Easy/Set Mismatch.java | 37 ++++++++++++++-----------------------
 1 file changed, 14 insertions(+), 23 deletions(-)

diff --git a/Easy/Set Mismatch.java b/Easy/Set Mismatch.java
index 49ba13f1..c75988bc 100644
--- a/Easy/Set Mismatch.java	
+++ b/Easy/Set Mismatch.java	
@@ -1,26 +1,17 @@
 class Solution {
-    public int[] findErrorNums(int[] nums) {
-        int[] ans = {-1,1};
-        Map<Integer, Integer> map = new HashMap<>();
-        
-        for(int i=0;i<nums.length;i++) {
-            if (map.containsKey(nums[i])) {
-                map.put(nums[i], map.get(nums[i])+1);
-            }
-            else {
-                map.put(nums[i], 1);
-            }
-        }
-        
-        for (int i=1;i<=nums.length;i++) {
-            if (!map.containsKey(i)) {
-                ans[1] = i;
-            }
-            if (map.containsKey(i) && map.get(i) == 2) {
-                ans[0] = i;
-            }
-        }
-        
-        return ans;
+  public int[] findErrorNums(int[] nums) {
+    Map<Integer, Integer> frequency = new HashMap<>();
+    for (int num : nums) {
+      frequency.put(num, frequency.getOrDefault(num, 0) + 1);
     }
+    int[] ans = new int[2];
+    for (int idx = 1; idx <= nums.length; idx++) {
+      if (!frequency.containsKey(idx)) {
+        ans[1] = idx;
+      } else if (frequency.get(idx) > 1) {
+        ans[0] = idx;
+      }
+    }
+    return ans;
+  }
 }

From 5efc356a131ee25c195c95a6282898ec7ee95b33 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 27 Oct 2020 08:07:26 -0700
Subject: [PATCH 0358/2175] Refactored Linked List Cycle II.java

---
 Medium/Linked List Cycle II.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/Medium/Linked List Cycle II.java b/Medium/Linked List Cycle II.java
index ba59422b..42ba6ee8 100644
--- a/Medium/Linked List Cycle II.java	
+++ b/Medium/Linked List Cycle II.java	
@@ -11,18 +11,16 @@
  */
 public class Solution {
   public ListNode detectCycle(ListNode head) {
-    ListNode slow = head;
     ListNode fast = head;
-    boolean cycle = false;
+    ListNode slow = head;
     while (fast != null && fast.next != null) {
       slow = slow.next;
       fast = fast.next.next;
       if (slow == fast) {
-        cycle = true;
         break;
       }
     }
-    if (!cycle) {
+    if (fast == null || fast.next == null) {
       return null;
     }
     slow = head;

From 0b870ba7b33baae4ea44813d958d6c544111c678 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 27 Oct 2020 11:58:29 -0700
Subject: [PATCH 0359/2175] Refactored Most Frequent Subtree Sum.java

---
 Medium/Most Frequent Subtree Sum.java | 80 ++++++++++++---------------
 1 file changed, 36 insertions(+), 44 deletions(-)

diff --git a/Medium/Most Frequent Subtree Sum.java b/Medium/Most Frequent Subtree Sum.java
index a547b5ad..0d892dc1 100644
--- a/Medium/Most Frequent Subtree Sum.java	
+++ b/Medium/Most Frequent Subtree Sum.java	
@@ -4,53 +4,45 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    Map<Integer, Integer> map = new HashMap<>();
-    int max = 0;
-    public int[] findFrequentTreeSum(TreeNode root) {
-        populateSum(root);
-        
-        int count = 0;
-        
-        for (Map.Entry<Integer, Integer> entry:map.entrySet()) {
-            if (entry.getValue() == max) {
-                count++;
-            }
-        }
-        
-        int[] ans = new int[count];
-        int i = 0;
-        
-        for (Map.Entry<Integer, Integer> entry:map.entrySet()) {
-            if (entry.getValue() == max) {
-                ans[i] = entry.getKey();
-                i++;
-            }
-        }
-        
-        return ans;
+  public int[] findFrequentTreeSum(TreeNode root) {
+    Map<Integer, Integer> subtreeSumFrequency = new HashMap<>();
+    Map<TreeNode, Integer> nodeToSum = new HashMap<>();
+    dfsHelper(root, nodeToSum, subtreeSumFrequency);
+    int maxFrequency = subtreeSumFrequency.values().stream()
+        .max(Comparator.comparingInt(Integer::intValue)).orElseGet(() -> 0);
+    return subtreeSumFrequency
+        .keySet()
+        .stream()
+        .filter(e -> subtreeSumFrequency.get(e) == maxFrequency)
+        .collect(Collectors.toList())
+        .stream()
+        .mapToInt(Integer::intValue)
+        .toArray();
+  }
+
+  private int dfsHelper(TreeNode node, Map<TreeNode, Integer> nodeToSum,
+      Map<Integer, Integer> subtreeSumFrequency) {
+    if (node == null) {
+      return 0;
     }
-    
-    public void populateSum(TreeNode root) {
-        
-        if (root == null) return; 
-        int sum = getSum(root);
-        map.put(sum, map.getOrDefault(sum, 0) + 1);
-        
-        max = Math.max(max, map.get(sum));
-        
-        populateSum(root.left);
-        populateSum(root.right);
-        
-    }
-    
-    public int getSum(TreeNode root) {
-        if (root == null) return 0;
-        
-        int sum = root.val;
-        return sum + getSum(root.left) + getSum(root.right);
+    if (nodeToSum.containsKey(node)) {
+      return nodeToSum.get(node);
     }
+    int leftSubtreeSum = dfsHelper(node.left, nodeToSum, subtreeSumFrequency);
+    int rightSubtreeSum = dfsHelper(node.right, nodeToSum, subtreeSumFrequency);
+    nodeToSum.put(node, node.val + leftSubtreeSum + rightSubtreeSum);
+    subtreeSumFrequency
+        .put(nodeToSum.get(node), subtreeSumFrequency.getOrDefault(nodeToSum.get(node), 0) + 1);
+    return nodeToSum.get(node);
+  }
 }

From 95992f54925fd55516418202c59aa24dccda4e6a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 28 Oct 2020 08:18:44 -0700
Subject: [PATCH 0360/2175] Refactored Summary Ranges.java

---
 Easy/Summary Ranges.java   | 19 +++++++++++++++++++
 Medium/Summary Ranges.java | 18 ------------------
 2 files changed, 19 insertions(+), 18 deletions(-)
 create mode 100644 Easy/Summary Ranges.java
 delete mode 100644 Medium/Summary Ranges.java

diff --git a/Easy/Summary Ranges.java b/Easy/Summary Ranges.java
new file mode 100644
index 00000000..97b5e753
--- /dev/null
+++ b/Easy/Summary Ranges.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public List<String> summaryRanges(int[] nums) {
+    List<String> ranges = new ArrayList<>();
+    int idx = 0;
+    while (idx < nums.length) {
+      int start = nums[idx++];
+      int end = start;
+      while (idx < nums.length && (nums[idx] - end) == 1) {
+        end = nums[idx++];
+      }
+      if (start == end) {
+        ranges.add(String.valueOf(start));
+      } else {
+        ranges.add(String.format("%d->%d", start, end));
+      }
+    }
+    return ranges;
+  }
+}
diff --git a/Medium/Summary Ranges.java b/Medium/Summary Ranges.java
deleted file mode 100644
index 340b0f30..00000000
--- a/Medium/Summary Ranges.java	
+++ /dev/null
@@ -1,18 +0,0 @@
-class Solution {
-  public List<String> summaryRanges(int[] nums) {
-    List<String> list = new ArrayList<>();
-    int idx = 0;
-    int n = nums.length;
-    while (idx < n) {
-      int start = nums[idx];
-      int prev = start;
-      idx++;
-      while (idx < n && nums[idx] - prev == 1) {
-        prev = nums[idx];
-        idx++;
-      }
-      list.add(start == prev ? String.valueOf(start) : String.valueOf(start + "->" + prev));
-    }
-    return list;
-  }
-}

From 92a46966096cbd8b2afee90a1700c6dbc9fdacb3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 28 Oct 2020 14:58:35 -0700
Subject: [PATCH 0361/2175] Added Throne Inheritence.java

---
 Medium/Throne Inheritence.java | 42 ++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Throne Inheritence.java

diff --git a/Medium/Throne Inheritence.java b/Medium/Throne Inheritence.java
new file mode 100644
index 00000000..49b2ed0c
--- /dev/null
+++ b/Medium/Throne Inheritence.java	
@@ -0,0 +1,42 @@
+class ThroneInheritance {
+  Map<String, ArrayList<String>> family;
+  Set<String> deadPeople;
+  String king;
+  public ThroneInheritance(String kingName) {
+    this.king = kingName;
+    family = new HashMap<>();
+    family.put(kingName, new ArrayList<>());
+    deadPeople = new HashSet<>();
+  }
+
+  public void birth(String parentName, String childName) {
+    family.computeIfAbsent(parentName, k -> new ArrayList<>()).add(childName);
+  }
+
+  public void death(String name) {
+    deadPeople.add(name);
+  }
+
+  public List<String> getInheritanceOrder() {
+    List<String> inheritenceOrder = new ArrayList<>();
+    findInheritenceRecursively(king, inheritenceOrder);
+    return inheritenceOrder;
+  }
+  
+  private void findInheritenceRecursively(String currPerson, List<String> inheritenceOrder) {
+    if (!deadPeople.contains(currPerson)) {
+      inheritenceOrder.add(currPerson);
+    }
+    for (String children : family.getOrDefault(currPerson, new ArrayList<>())) {
+      findInheritenceRecursively(children, inheritenceOrder);
+    }
+  }
+}
+
+/**
+ * Your ThroneInheritance object will be instantiated and called as such:
+ * ThroneInheritance obj = new ThroneInheritance(kingName);
+ * obj.birth(parentName,childName);
+ * obj.death(name);
+ * List<String> param_3 = obj.getInheritanceOrder();
+ */

From 966ebe34b8bf0204e35d2552e2a8037705b7fc81 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 29 Oct 2020 06:51:15 -0700
Subject: [PATCH 0362/2175] Refactored Maximize Distance to Closest Person.java

---
 Easy/Maximize Distance to Closest Person.java | 23 --------------
 .../Maximize Distance to Closest Person.java  | 30 +++++++++++++++++++
 2 files changed, 30 insertions(+), 23 deletions(-)
 delete mode 100644 Easy/Maximize Distance to Closest Person.java
 create mode 100644 Medium/Maximize Distance to Closest Person.java

diff --git a/Easy/Maximize Distance to Closest Person.java b/Easy/Maximize Distance to Closest Person.java
deleted file mode 100644
index a5d4d304..00000000
--- a/Easy/Maximize Distance to Closest Person.java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class Solution {
-  public int maxDistToClosest(int[] seats) {
-    int start = -1;
-    int max = 0;
-    int n = seats.length;
-    for (int i = 0; i < n; i++) {
-      if (seats[i] == 0) {
-        continue;
-      }
-      if (start == -1) {
-        max = Math.max(max, i);
-      }
-      else {
-        max = Math.max(max, (i - start) / 2);
-      }
-      start = i;
-    }
-    if (seats[n - 1] == 0) {
-      max = Math.max(max, n - 1 - start);
-    }
-    return max;
-  }
-}
diff --git a/Medium/Maximize Distance to Closest Person.java b/Medium/Maximize Distance to Closest Person.java
new file mode 100644
index 00000000..7b65d4de
--- /dev/null
+++ b/Medium/Maximize Distance to Closest Person.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public int maxDistToClosest(int[] seats) {
+    int numberOfSeats = seats.length;
+    int[] distanceFromRight = new int[numberOfSeats];
+    int[] distanceFromLeft = new int[numberOfSeats];
+    for (int i = 1; i < numberOfSeats; i++) {
+      if (seats[i - 1] == 0 && seats[i] == 0) {
+          distanceFromLeft[i] = distanceFromLeft[i - 1] + 1;
+      }
+    }
+    for (int i = numberOfSeats - 2; i >= 0; i--) {
+      if (seats[i + 1] != 1 && seats[i] == 0) {
+          distanceFromRight[i] = distanceFromRight[i + 1] + 1;
+      }
+    }
+    int maxDistance = 0;
+    for (int i = 0; i < numberOfSeats; i++) {
+      if (i == 0 || i == numberOfSeats - 1) {
+        maxDistance = Math.max(
+          maxDistance, Math.max(distanceFromLeft[i], distanceFromRight[i])
+        );
+      } else {
+        maxDistance = Math.max(
+          maxDistance, Math.min(distanceFromLeft[i], distanceFromRight[i])
+        );
+      }
+    }
+    return maxDistance + 1;
+  }
+}

From 8a43179f6bd2eaffcf84c8d90f26ba231d4695bc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 29 Oct 2020 07:03:04 -0700
Subject: [PATCH 0363/2175] Refactored Linked List Components.java

---
 Medium/Linked List Components.java | 38 +++++++++++++-----------------
 1 file changed, 17 insertions(+), 21 deletions(-)

diff --git a/Medium/Linked List Components.java b/Medium/Linked List Components.java
index 1d32410d..62322281 100644
--- a/Medium/Linked List Components.java	
+++ b/Medium/Linked List Components.java	
@@ -3,30 +3,26 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public int numComponents(ListNode head, int[] G) {
-        int count = 0;
-        Set<Integer> set = new HashSet<>();
-        for (int g : G) {
-            set.add(g);
+  public int numComponents(ListNode head, int[] G) {
+    int numOfComponents = 0;
+    Set<Integer> set = Arrays.stream(G).boxed().collect(Collectors.toSet());
+    while (head != null && !set.isEmpty()) {
+      if (set.contains(head.val)) {
+        while (head != null && !set.isEmpty() && set.contains(head.val)) {
+          set.remove(head.val);
+          head = head.next;
         }
-        
-        while (head != null) {
-            if (set.contains(head.val)) {
-                while (head != null && set.contains(head.val)) {
-                    head = head.next;
-                }
-                
-                count++;
-            }
-            else {
-                head = head.next;
-            }
-        }
-        
-        return count;
+        numOfComponents++;
+      } else {
+        head = head.next;
+      }
     }
+    return numOfComponents;
+  }
 }

From 4eaf851ee981494cf3a7602e8aa9b1ea293e1cdf Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 29 Oct 2020 15:01:53 -0700
Subject: [PATCH 0364/2175] Refactored Kth Smallest Element in a Sorted
 Matrix.java

---
 ...h Smallest Element in a Sorted Matrix.java | 50 +++++++------------
 1 file changed, 17 insertions(+), 33 deletions(-)

diff --git a/Medium/Kth Smallest Element in a Sorted Matrix.java b/Medium/Kth Smallest Element in a Sorted Matrix.java
index 37f81aec..1eaf99e7 100644
--- a/Medium/Kth Smallest Element in a Sorted Matrix.java	
+++ b/Medium/Kth Smallest Element in a Sorted Matrix.java	
@@ -1,37 +1,21 @@
 class Solution {
-    public int kthSmallest(int[][] matrix, int k) {
-        PriorityQueue<Element> pq = new PriorityQueue<>(new Comparator<Element>() {
-            @Override
-            public int compare(Element o1, Element o2) {
-                return o1.val - o2.val;
-            }
-        });
-        
-        for (int i=0; i<matrix[0].length; i++) {
-            pq.offer(new Element(matrix[0][i], 0, i));
-        }
-        
-        for (int i=0; i<k-1; i++) {
-            Element temp = pq.poll();
-            if (temp.x == matrix.length-1) {
-                continue;
-            }
-            
-            pq.offer(new Element(matrix[temp.x+1][temp.y], temp.x+1, temp.y));
-        }
-        
-        return pq.poll().val;
+  public int kthSmallest(int[][] matrix, int k) {
+    int numOfRows = matrix.length;
+    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
+      public int compare(int[] o1, int[] o2) {
+        return o1[2] - o2[2];
+      }
+    });
+    for (int j = 0; j < numOfRows; j++) {
+      pq.add(new int[]{0, j, matrix[0][j]});
     }
-
-    class Element {
-        int val;
-        int x;
-        int y;
-
-        public Element(int val, int x, int y) {
-            this.val = val;
-            this.x = x;
-            this.y = y;
-        }
+    for (int i = 0; i < k - 1; i++) {
+      int[] removed = pq.poll();
+      if (removed[0] == numOfRows - 1) {
+        continue;
+      }
+      pq.add(new int[]{removed[0] + 1, removed[1], matrix[removed[0] + 1][removed[1]]});
     }
+    return pq.peek()[2];
+  }
 }

From 32261667a41622d01138c54cc2790af64408f0e2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 30 Oct 2020 09:04:04 -0700
Subject: [PATCH 0365/2175] Added Lemonade Change.java

---
 Easy/Lemonade Change.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Easy/Lemonade Change.java

diff --git a/Easy/Lemonade Change.java b/Easy/Lemonade Change.java
new file mode 100644
index 00000000..ec201343
--- /dev/null
+++ b/Easy/Lemonade Change.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public boolean lemonadeChange(int[] bills) {
+    final int LEMONADE_COST = 5;
+    int[] billDenominations = {20, 10, 5};
+    Map<Integer, Integer> cashCounter = new HashMap<>();
+    for (int bill : bills) {
+      int changeRequired = bill - LEMONADE_COST;
+      cashCounter.put(bill, cashCounter.getOrDefault(bill, 0) + 1);
+      for (Integer denomination : billDenominations) {
+        int numOfBills = Math.min(
+            changeRequired / denomination, cashCounter.getOrDefault(denomination, 0)
+        );
+        changeRequired -= denomination * numOfBills;
+        cashCounter.put(
+          denomination, cashCounter.getOrDefault(denomination, 0) - numOfBills
+        );
+      }
+      if (changeRequired > 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

From 8375d4c3f7b3589791d0dca8c677adf38a7df0d3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 31 Oct 2020 17:57:39 -0700
Subject: [PATCH 0366/2175] Added Sort Array by Increasing Frequency.java

---
 Easy/Sort Array by Increasing Frequency.java | 21 ++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Sort Array by Increasing Frequency.java

diff --git a/Easy/Sort Array by Increasing Frequency.java b/Easy/Sort Array by Increasing Frequency.java
new file mode 100644
index 00000000..70512785
--- /dev/null
+++ b/Easy/Sort Array by Increasing Frequency.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int[] frequencySort(int[] nums) {
+    Map<Integer, Long> counter = Arrays.stream(nums).boxed()
+        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())
+    );
+    PriorityQueue<Integer> frequencyMinHeap = new PriorityQueue<>((o1, o2) -> {
+      int c = (int) (counter.get(o1) - counter.get(o2));
+      return c != 0 ? c : o2 - o1;
+    });
+    frequencyMinHeap.addAll(counter.keySet());
+    int[] sortedByFrequency = new int[nums.length];
+    for (int idx = 0; idx < sortedByFrequency.length;) {
+      int value = frequencyMinHeap.poll();
+      long count = counter.get(value);
+      while (count-- > 0) {
+        sortedByFrequency[idx++] = value;
+      }
+    }
+    return sortedByFrequency;
+  }
+}

From 89ff1f4b570f105051072a2923bb1f11fa661155 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 31 Oct 2020 22:48:04 -0700
Subject: [PATCH 0367/2175] Added Check Array Formation Through
 Concatenation.java

---
 ...k Array Formation Through Concatenation.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Check Array Formation Through Concatenation.java

diff --git a/Easy/Check Array Formation Through Concatenation.java b/Easy/Check Array Formation Through Concatenation.java
new file mode 100644
index 00000000..c3fb461d
--- /dev/null
+++ b/Easy/Check Array Formation Through Concatenation.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean canFormArray(int[] arr, int[][] pieces) {
+    Map<Integer, Integer> indexMap = new HashMap<>();
+    for (int idx = 0; idx < arr.length; idx++) {
+      indexMap.put(arr[idx], idx);
+    }
+    for (int[] piece : pieces) {
+      for (int idx = 0; idx < piece.length; idx++) {
+        if (!indexMap.containsKey(piece[idx]) || 
+            idx > 0 && indexMap.getOrDefault(piece[idx], -1) < indexMap.getOrDefault(piece[idx - 1], -1)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+}

From 01af7f3d519cc099f9f536e51efa8ee7d1897c02 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 1 Nov 2020 07:13:51 -0800
Subject: [PATCH 0368/2175] Added Count Sorted Vowel Strings.java

---
 Medium/Count Sorted Vowel Strings.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Count Sorted Vowel Strings.java

diff --git a/Medium/Count Sorted Vowel Strings.java b/Medium/Count Sorted Vowel Strings.java
new file mode 100644
index 00000000..757bf96e
--- /dev/null
+++ b/Medium/Count Sorted Vowel Strings.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int countVowelStrings(int n) {
+    Integer[][] memo = new Integer[n + 1][5];
+    return topDownDP(n, 0, memo);
+  }
+  
+  private int topDownDP(int n, int idx, Integer[][] memo) {
+    if (n == 0) {
+      return 1;
+    } else if (idx == 5) {
+      return 0;
+    } else if (memo[n][idx] != null) {
+      return memo[n][idx];
+    }
+    int numOfPermutations = topDownDP(n, idx + 1, memo);
+    numOfPermutations += topDownDP(n - 1, idx, memo);
+    return memo[n][idx] = numOfPermutations;
+  }
+}

From 0fc8146eaf0fdd25a7d03a60796b95fe3bf466f5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 1 Nov 2020 10:00:26 -0800
Subject: [PATCH 0369/2175] Added Replace All ?'s to Avoid Consecutive
 Repeating Characters.java

---
 ...void Consecutive Repeating Characters.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Replace All ?'s to Avoid Consecutive Repeating Characters.java

diff --git a/Easy/Replace All ?'s to Avoid Consecutive Repeating Characters.java b/Easy/Replace All ?'s to Avoid Consecutive Repeating Characters.java
new file mode 100644
index 00000000..57c5a54c
--- /dev/null
+++ b/Easy/Replace All ?'s to Avoid Consecutive Repeating Characters.java	
@@ -0,0 +1,22 @@
+class Solution {
+  private final char[] ALL_CHARACTERS = "abcdefghijklmnopqrstuvwxyz".toCharArray();
+  public String modifyString(String s) {
+    char[] charArray = s.toCharArray();
+    for (int idx = 0; idx < charArray.length; idx++) {
+      if (charArray[idx] == '?') {
+        charArray[idx] = getNonRepeatingChar(charArray, idx);
+      }
+    }
+    return String.valueOf(charArray);
+  }
+  
+  private char getNonRepeatingChar(char[] charArray, int idx) {
+    for (char c : ALL_CHARACTERS) {
+      if ((idx == 0 || charArray[idx - 1] == '?' || charArray[idx - 1] != c) && 
+          (idx == charArray.length - 1 || charArray[idx + 1] == '?' || charArray[idx + 1] != c)) {
+        return c;
+      }
+    }
+    return charArray[idx];
+  }
+}

From 5721daf1c3a9ddf29b3ec1a8f814035a8b2ec759 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 2 Nov 2020 07:24:49 -0800
Subject: [PATCH 0370/2175] Refactored Count Primes.java

---
 Easy/Count Primes.java | 33 ++++++++++++++-------------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/Easy/Count Primes.java b/Easy/Count Primes.java
index e6cbb56b..9b9347a0 100644
--- a/Easy/Count Primes.java	
+++ b/Easy/Count Primes.java	
@@ -1,23 +1,18 @@
 class Solution {
-    public int countPrimes(int n) {
-        int[] arr = new int[n];
-        
-        for (int i=2;i<n;i++) {
-            if (arr[i] != 1) {            
-                for (int j = i*2;j<n;j+=i) {
-                    arr[j] = 1;
-                }
-            } 
-            else {
-                arr[i] = 1;
-            }
+  public int countPrimes(int n) {
+    boolean[] isPrime = new boolean[n];
+    Arrays.fill(isPrime, true);
+    for (int i = 2; i * i < n; i++) {
+      if (isPrime[i]) {
+        for (int j = i * i; j < n; j += i) {
+          isPrime[j] = false;
         }
-        
-        int count = 0;
-        for (int i=2;i<n;i++) {
-            if (arr[i] == 0) count++;
-        }
-        
-        return count;
+      }
+    }
+    int numOfPrimes = 0;
+    for (int i = 2; i < n; i++) {
+      numOfPrimes += isPrime[i] ? 1 : 0;
     }
+    return numOfPrimes;
+  }
 }

From d80cd511f0ad5066081cd2ba31007903d63caead Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 3 Nov 2020 08:40:02 -0800
Subject: [PATCH 0371/2175] Refactored Consecutive Characters.java

---
 Easy/Consecutive Characters.java | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/Easy/Consecutive Characters.java b/Easy/Consecutive Characters.java
index cb37c58b..594b38c9 100644
--- a/Easy/Consecutive Characters.java	
+++ b/Easy/Consecutive Characters.java	
@@ -1,17 +1,14 @@
 class Solution {
   public int maxPower(String s) {
-    int count = 0;
-    int idx = 0;
-    int n = s.length();
-    while (idx < n) {
-      char c = s.charAt(idx);
-      int tempCount = 0;
-      while (idx < n && s.charAt(idx) == c) {
+    int maximumRepeatingCount = 0;
+    for (int idx = 0; idx < s.length();) {
+      char currentChar = s.charAt(idx);
+      int currIdx = idx;
+      while (idx < s.length() && s.charAt(idx) == currentChar) {
         idx++;
-        tempCount++;
       }
-      count = Math.max(count, tempCount);
+      maximumRepeatingCount = Math.max(maximumRepeatingCount, idx - currIdx);
     }
-    return count;
+    return maximumRepeatingCount;
   }
 }

From 46b1055ec4404fba2899d29425f2c61312155f2d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 3 Nov 2020 21:41:39 -0800
Subject: [PATCH 0372/2175] Added Check If a String Can Break Another
 String.java

---
 ... If a String Can Break Another String.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Medium/Check If a String Can Break Another String.java

diff --git a/Medium/Check If a String Can Break Another String.java b/Medium/Check If a String Can Break Another String.java
new file mode 100644
index 00000000..0e9e9f55
--- /dev/null
+++ b/Medium/Check If a String Can Break Another String.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public boolean checkIfCanBreak(String s1, String s2) {
+    int n = s1.length();
+    int[] counterS1 = new int[26];
+    int[] counterS2 = new int[26];
+    for (int idx = 0; idx < n; idx++) {
+      counterS1[s1.charAt(idx) - 'a']++;
+      counterS2[s2.charAt(idx) - 'a']++;
+    }
+    int countS1 = 0;
+    int countS2 = 0;
+    int side = 0;
+    for (int idx = 0; idx < 26; idx++) {
+      countS1 += counterS1[idx];
+      countS2 += counterS2[idx];
+      if (countS1 > countS2) {
+        if (side == 1) {
+          return false;
+        }
+        side = -1;
+      } else if (countS2 > countS1) {
+        if (side == -1) {
+          return false;
+        }
+        side = 1;
+      }
+    }
+    return true;
+  }
+}

From e7f4a8f8a583713a0393a569b385b543bf10f777 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 4 Nov 2020 06:26:16 -0800
Subject: [PATCH 0373/2175] Refactored Minimum Height Trees.java

---
 Medium/Minimum Height Trees.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Medium/Minimum Height Trees.java b/Medium/Minimum Height Trees.java
index 8bf0e21f..a92f7494 100644
--- a/Medium/Minimum Height Trees.java	
+++ b/Medium/Minimum Height Trees.java	
@@ -4,7 +4,7 @@ public List<Integer> findMinHeightTrees(int n, int[][] edges) {
       return Collections.singletonList(0);
     }
     Map<Integer, Set<Integer>> map = new HashMap<>();
-    for (int[] edge: edges) {
+    for (int[] edge : edges) {
       map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
       map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
     }
@@ -19,7 +19,8 @@ public List<Integer> findMinHeightTrees(int n, int[][] edges) {
       int size = leaves.size();
       count -= size;
       List<Integer> newLeaves = new ArrayList<>();
-      for (int leaf : leaves) {
+      for (int i = 0; i < size; i++) {
+        int leaf = leaves.get(i);
         for (int toRemove : map.getOrDefault(leaf, new HashSet<>())) {
           map.get(toRemove).remove(leaf);
           if (map.get(toRemove).size() == 1) {

From 32a324e8f814dd403f12df5c19a9d183780a790c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 4 Nov 2020 09:28:45 -0800
Subject: [PATCH 0374/2175] Added Pseudo-Palindromic Paths in a Binary
 Tree.java

---
 ...do-Palindromic Paths in a Binary Tree.java | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 Medium/Pseudo-Palindromic Paths in a Binary Tree.java

diff --git a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java
new file mode 100644
index 00000000..f6b9498f
--- /dev/null
+++ b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java	
@@ -0,0 +1,51 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int pseudoPalindromicPaths (TreeNode root) {
+    int[] map = new int[10];
+    int[] count = {0};
+    pseudoPalindromicPathsUtil(root, map, count);
+    return count[0];
+  }
+  
+  private boolean isPalindrome(int[] map) {
+    boolean oddFound = false;
+    for(int i = 1; i <= 9; i++) {
+      if (map[i] % 2 != 0) {
+        if (oddFound) {
+          return false;
+        }
+        oddFound = true;
+      }
+    }
+    return true;
+  }
+  
+  private void pseudoPalindromicPathsUtil(TreeNode root, int[] map, int[] count) {
+    if (root == null) {
+      return;
+    }
+    map[root.val] = map[root.val] + 1;
+    if (root.left == null && root.right == null) {
+      if (isPalindrome(map)) {
+        count[0]++;
+      }
+    }
+    pseudoPalindromicPathsUtil(root.left, map, count);
+    pseudoPalindromicPathsUtil(root.right, map, count);
+    map[root.val] = map[root.val] - 1;
+  }
+}

From 624d6a9bc634f753758e0371d4a66a9ec2a61a65 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 5 Nov 2020 10:56:26 -0800
Subject: [PATCH 0375/2175] Added Sort An Array.java

---
 Medium/Sort An Array.java | 52 ++++++++++++++++++++++++++++-----------
 1 file changed, 37 insertions(+), 15 deletions(-)

diff --git a/Medium/Sort An Array.java b/Medium/Sort An Array.java
index 7d4a1a41..7c3f105e 100644
--- a/Medium/Sort An Array.java	
+++ b/Medium/Sort An Array.java	
@@ -1,18 +1,40 @@
 class Solution {
-    public int[] sortArray(int[] nums) {
-        int[] counter = new int[2 * 50000 + 1];
-        for (int num : nums) {
-            counter[50000 + num]++;
-        }
-        
-        int idx = 0;
-        for (int i = 0; i < counter.length; i++) {
-            int val = i > 50000 ? i - 50000 : -(50000 - i);
-            while (counter[i]-- > 0) {
-                nums[idx++] = val;
-            }
-        }
-        
-        return nums;
+  public int[] sortArray(int[] nums) {
+    int n = nums.length - 1;
+    mergeSort(nums, 0, n);
+    return nums;
+  }
+  
+  private void mergeSort(int[] nums, int start, int end) {
+    if (end - start + 1 <= 1) {
+      return;
     }
+    int mid = start + (end - start) / 2;
+    mergeSort(nums, start, mid);
+    mergeSort(nums, mid + 1, end);
+    merge(nums, start, mid, end);
+  }
+  
+  private void merge(int[] nums, int start, int mid, int end) {
+    int left = start;
+    int right = mid + 1;
+    int[] temp = new int[end - start + 1];
+    int idx = 0;
+    while (left <= mid && right <= end) {
+      if (nums[left] < nums[right]) {
+        temp[idx++] = nums[left++];
+      } else {
+        temp[idx++] = nums[right++];
+      }
+    }
+    while (left <= mid) {
+      temp[idx++] = nums[left++];
+    }
+    while (right <= end) {
+      temp[idx++] = nums[right++];
+    }
+    for (int i = start; i <= end; i++) {
+      nums[i] = temp[i - start];
+    }
+  }
 }

From eb4ad09969a44aacee1590eecf7437f4307b0f20 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 8 Nov 2020 07:59:52 -0800
Subject: [PATCH 0376/2175] Added Get Maximum in Generated Array.java

---
 Easy/Get Maximum in Generated Array.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Get Maximum in Generated Array.java

diff --git a/Easy/Get Maximum in Generated Array.java b/Easy/Get Maximum in Generated Array.java
new file mode 100644
index 00000000..58ae1efe
--- /dev/null
+++ b/Easy/Get Maximum in Generated Array.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int getMaximumGenerated(int n) {
+    if (n == 0) {
+      return 0;
+    }
+    int[] nums = new int[n + 1];
+    nums[0] = 0;
+    nums[1] = 1;
+    int max = 1;
+    for (int i = 2; i <= n; i++) {
+      if (i % 2 == 0) {
+        nums[i] = nums[i / 2];
+      } else {
+        nums[i] = nums[i / 2] + nums[i / 2 + 1];
+      }
+      max = Math.max(nums[i], max);
+    }
+    return max;
+  }
+}

From cd7338ec172cba70a95d941626963c117ca68401 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 8 Nov 2020 19:21:16 -0800
Subject: [PATCH 0377/2175] Added Minimum Deletions to Make Character
 Frequencies Unique.java

---
 ... to Make Character Frequencies Unique.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Minimum Deletions to Make Character Frequencies Unique.java

diff --git a/Medium/Minimum Deletions to Make Character Frequencies Unique.java b/Medium/Minimum Deletions to Make Character Frequencies Unique.java
new file mode 100644
index 00000000..f05bace6
--- /dev/null
+++ b/Medium/Minimum Deletions to Make Character Frequencies Unique.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int minDeletions(String s) {
+    int[] frequencies = new int[26];
+    for (char c : s.toCharArray()) {
+      frequencies[c - 'a']++;
+    }
+    Arrays.sort(frequencies);
+    int expectedFrequency = frequencies[25];
+    int numOfDeletions = 0;
+    for (int i = 25; i >= 0; i--) {
+      if (frequencies[i] == 0) {
+        break;
+      }
+      if (frequencies[i] > expectedFrequency) {
+        numOfDeletions += frequencies[i] - expectedFrequency;
+      } else {
+        expectedFrequency = frequencies[i];
+      }
+      if (expectedFrequency > 0) {
+        expectedFrequency--;
+      }
+    }
+    return numOfDeletions;
+  } 
+}

From 65ec305d67efb67b22239da29536169c7a46d34b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 9 Nov 2020 05:40:49 -0800
Subject: [PATCH 0378/2175] Added Maximum Difference Between Node and
 Ancestor.java

---
 ... Difference Between Node and Ancestor.java | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Maximum Difference Between Node and Ancestor.java

diff --git a/Medium/Maximum Difference Between Node and Ancestor.java b/Medium/Maximum Difference Between Node and Ancestor.java
new file mode 100644
index 00000000..75d54cfa
--- /dev/null
+++ b/Medium/Maximum Difference Between Node and Ancestor.java	
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int maxAncestorDiff(TreeNode root) {
+    return dfs(root, root.val, root.val);
+  }
+  
+  private int dfs(TreeNode root, int min, int max) {
+    if (root == null) {
+      return max - min;
+    }
+    max = Math.max(root.val, max);
+    min = Math.min(root.val, min);
+    return Math.max(dfs(root.left, min, max), dfs(root.right, min, max));
+  }
+}

From 7c37e16c3aefdf7ac41ec9c8d7ea8c179b176459 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 9 Nov 2020 16:37:03 -0800
Subject: [PATCH 0379/2175] Added Construct K Palindrome Strings.java

---
 Medium/Construct K Palindrome Strings.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Construct K Palindrome Strings.java

diff --git a/Medium/Construct K Palindrome Strings.java b/Medium/Construct K Palindrome Strings.java
new file mode 100644
index 00000000..04f54681
--- /dev/null
+++ b/Medium/Construct K Palindrome Strings.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public boolean canConstruct(String s, int k) {
+    if (s.length() < k) {
+      return false;
+    }
+    int[] counter = new int[26];
+    int numOfOddOccurence = 0;
+    for (char c : s.toCharArray()) {
+      counter[c - 'a']++;
+      numOfOddOccurence += counter[c - 'a'] % 2 == 0 ? -1 : 1;
+    }
+    return numOfOddOccurence <= k;
+  }   
+}

From b28215954a43fd26764cf74a7a31cb318dd58ad2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 10 Nov 2020 06:35:04 -0800
Subject: [PATCH 0380/2175] Refactored Flipping an Image.java

---
 Easy/Flipping an Image.java | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/Easy/Flipping an Image.java b/Easy/Flipping an Image.java
index 8c4a0813..0e5d44f3 100644
--- a/Easy/Flipping an Image.java	
+++ b/Easy/Flipping an Image.java	
@@ -1,17 +1,14 @@
 class Solution {
   public int[][] flipAndInvertImage(int[][] A) {
-    for (int[] arr : A) {
-      int start = 0;
-      int end = arr.length - 1;
-      while (start < end) {
-        int temp = arr[start];
-        arr[start++] = arr[end];
-        arr[end--] = temp;
-      }
-    }
-    for (int[] arr : A) {
-      for (int i = 0; i < arr.length; i++) {
-        arr[i] = arr[i] == 1 ? 0 : 1;
+    int numRows = A.length;
+    int numCols = A[0].length - 1;
+    for (int rowIdx = 0; rowIdx < numRows; rowIdx++) {
+      int startIdx = 0;
+      int endIdx = numCols;
+      while (startIdx <= endIdx) {
+        int temp = A[rowIdx][startIdx];
+        A[rowIdx][startIdx++] = A[rowIdx][endIdx] == 1 ? 0 : 1;
+        A[rowIdx][endIdx--] = temp == 1 ? 0 : 1;
       }
     }
     return A;

From 16f2be32e04785e73dd4489a611e688b6fd09490 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 10 Nov 2020 07:30:52 -0800
Subject: [PATCH 0381/2175] Refactored Smallest String Starting From Leaf.java

---
 .../Smallest String Starting From Leaf.java   | 51 +++++++++----------
 1 file changed, 24 insertions(+), 27 deletions(-)

diff --git a/Medium/Smallest String Starting From Leaf.java b/Medium/Smallest String Starting From Leaf.java
index d890af9e..6948a960 100644
--- a/Medium/Smallest String Starting From Leaf.java	
+++ b/Medium/Smallest String Starting From Leaf.java	
@@ -4,36 +4,33 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public String smallestFromLeaf(TreeNode root) {
-        return helper(root);
+  public String smallestFromLeaf(TreeNode root) {
+    return dfs(root, "");
+  }
+  
+  private String dfs(TreeNode root, String curr) {
+    if (root == null) {
+      return curr;
     }
-    
-    private String helper(TreeNode root) {
-        if (root == null) {
-            return null;
-        }
-        
-        char ch = (char) (97 + root.val);
-        String leftVal = helper(root.left);
-        String rightVal = helper(root.right);
-        
-        if (leftVal == null && rightVal == null) {
-            return "" + ch;
-        }
-        
-        if (root.left == null || root.right == null) {
-            return rightVal == null ? leftVal + ch : rightVal + ch;
-        }
-        
-        if (rightVal.compareTo(leftVal) > 0) {
-            return leftVal + ch;
-        }
-        else {
-            return rightVal + ch;
-        }
+    curr = "" + (char)(97 + root.val) + curr;
+    if (root.left == null && root.right == null) {
+      return curr;
+    } else if (root.left == null || root.right == null) {
+      return root.left == null ? dfs(root.right, curr) : dfs(root.left, curr);
+    } else {
+      String left = dfs(root.left, curr);
+      String right = dfs(root.right, curr);
+      return left.compareTo(right) <= 0 ? left : right;
     }
+  }
 }

From e9a868495504d378299628b858084b024fe3be36 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 11 Nov 2020 07:29:46 -0800
Subject: [PATCH 0382/2175] Added Valid Square.java

---
 Medium/Valid Square.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Valid Square.java

diff --git a/Medium/Valid Square.java b/Medium/Valid Square.java
new file mode 100644
index 00000000..31a72df4
--- /dev/null
+++ b/Medium/Valid Square.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean validSquare(int[] p1, int[] p2, int[] p3, int[] p4) {
+    int[][] points = {p1, p2, p3, p4};
+    Arrays.sort(points, (i1, i2) -> i2[0] == i1[0] ? i1[1] - i2[1] : i1[0] - i2[0]);
+    return (
+      getDistance(points[0], points[1]) != 0 && 
+      getDistance(points[0], points[1]) == getDistance(points[1], points[3]) && 
+      getDistance(points[1], points[3]) == getDistance(points[3], points[2]) && 
+      getDistance(points[3], points[2]) == getDistance(points[2], points[0]) && 
+      getDistance(points[0],points[3])==getDistance(points[1],points[2])
+    );
+  }
+
+  private double getDistance(int[] p1, int[] p2) {
+    return (p2[1] - p1[1]) * (p2[1] - p1[1]) + (p2[0] - p1[0]) * (p2[0] - p1[0]);
+  }
+}

From 66abd34544ba519918ebfcddf1bcded62e939351 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 11 Nov 2020 12:41:21 -0800
Subject: [PATCH 0383/2175] Added Queries on a Permutation With Key.java

---
 Medium/Queries on a Permutation With Key.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Queries on a Permutation With Key.java

diff --git a/Medium/Queries on a Permutation With Key.java b/Medium/Queries on a Permutation With Key.java
new file mode 100644
index 00000000..5738ab0c
--- /dev/null
+++ b/Medium/Queries on a Permutation With Key.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int[] processQueries(int[] queries, int m) {
+    LinkedList<Integer> list = new LinkedList<>();
+    for (int i = 1; i <= m; i++) {
+      list.add(i);
+    }
+    int[] result = new int[queries.length];
+    for (int i = 0; i < queries.length; i++) {
+      int idx = list.indexOf(queries[i]);
+      result[i] = idx;
+      list.remove(idx);
+      list.addFirst(queries[i]);
+    }
+    return result;
+  }   
+}

From 02eaa6742063c80f18bab5623dbfbba08c5b67e7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 11 Nov 2020 17:43:22 -0800
Subject: [PATCH 0384/2175] Refactored Reverse Substrings Between Each Pair of
 Parentheses.java

---
 ...ings Between Each Pair of Parentheses.java | 37 ++++++++++++-------
 1 file changed, 23 insertions(+), 14 deletions(-)

diff --git a/Medium/Reverse Substrings Between Each Pair of Parentheses.java b/Medium/Reverse Substrings Between Each Pair of Parentheses.java
index 082685e4..b4bff4b6 100644
--- a/Medium/Reverse Substrings Between Each Pair of Parentheses.java	
+++ b/Medium/Reverse Substrings Between Each Pair of Parentheses.java	
@@ -1,17 +1,26 @@
 class Solution {
-    public String reverseParentheses(String s) {
-        int start = 0;
-        int end = 0;
-        for (int i = 0; i < s.length(); i++) {
-            if (s.charAt(i) == '(') {
-                start = i;
-            }
-            if (s.charAt(i) == ')') {
-                end = i;
-                StringBuilder sb = new StringBuilder(s.substring(start + 1, end)).reverse();
-                return reverseParentheses(s.substring(0, start) + sb.toString() + s.substring(end + 1));
-            }
-        }
-        return s;
+  public String reverseParentheses(String s) {
+    Stack<Integer> opened = new Stack<>();
+    int n = s.length();
+    int[] pair = new int[n];
+    for (int i = 0; i < n; i++) {
+      if (s.charAt(i) == '(') {
+        opened.push(i);
+      } else if (s.charAt(i) == ')') {
+        int startIdx = opened.pop();
+        pair[i] = startIdx;
+        pair[startIdx] = i;
+      }
     }
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0, jump = 1; i < n; i += jump) {
+      if (s.charAt(i) == '(' || s.charAt(i) == ')') {
+        i = pair[i];
+        jump = -jump;
+      } else {
+        sb.append(s.charAt(i));
+      }
+    }
+    return sb.toString();
+  }
 }

From 71586f70e9f7a1db0a59fae325bc30276b13ee59 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 11 Nov 2020 18:08:01 -0800
Subject: [PATCH 0385/2175] Added Find the Winner of an Array Game.java

---
 Medium/Find the Winner of an Array Game.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Find the Winner of an Array Game.java

diff --git a/Medium/Find the Winner of an Array Game.java b/Medium/Find the Winner of an Array Game.java
new file mode 100644
index 00000000..0c7130f4
--- /dev/null
+++ b/Medium/Find the Winner of an Array Game.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int getWinner(int[] arr, int k) {
+    int currentElement = arr[0];
+    int n = arr.length;
+    int currentWinCount = 0;
+    for (int i = 1; i < n; i++) {
+      if (arr[i] > currentElement) {
+        currentElement = arr[i];
+        currentWinCount = 0;
+      }
+      if (++currentWinCount == k) {
+        break;
+      }
+    }
+    return currentElement;
+  }
+}

From cb92eff5f5c7314e8d3c4307031acdd3467c1b09 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 12 Nov 2020 07:58:22 -0800
Subject: [PATCH 0386/2175] Added Check If All 1's Are at Least Length K Places
 Away.java

---
 ...f All 1's Are at Least Length K Places Away.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Check If All 1's Are at Least Length K Places Away.java

diff --git a/Medium/Check If All 1's Are at Least Length K Places Away.java b/Medium/Check If All 1's Are at Least Length K Places Away.java
new file mode 100644
index 00000000..bc272afa
--- /dev/null
+++ b/Medium/Check If All 1's Are at Least Length K Places Away.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public boolean kLengthApart(int[] nums, int k) {
+    for (int start = -1, idx = 0; idx < nums.length; idx++) {
+      if (nums[idx] == 1) {
+        if (start != -1 && idx - start - 1 < k) {
+          return false;
+        }
+        start = idx;
+      }
+    }
+    return true;
+  }
+}

From 1e255003271e9c25c6230fe883c51ae93f70ab84 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 12 Nov 2020 08:01:45 -0800
Subject: [PATCH 0387/2175] Refactored Binary Number with Alternating Bits.java

---
 Easy/Binary Number with Alternating Bits.java | 21 +++++++++++--------
 README.md                                     |  2 +-
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/Easy/Binary Number with Alternating Bits.java b/Easy/Binary Number with Alternating Bits.java
index 8b0bde44..82288dd5 100644
--- a/Easy/Binary Number with Alternating Bits.java	
+++ b/Easy/Binary Number with Alternating Bits.java	
@@ -1,12 +1,15 @@
 class Solution {
-    public boolean hasAlternatingBits(int n) {
-        int prev = n%2;
-        n /=2;
-        while (n>0) {
-            if (n%2 == prev) return false;
-            prev = n%2;
-            n /= 2;
-        }
-        return true;
+  public boolean hasAlternatingBits(int n) {
+    Integer prev = null;
+    while (n > 0) {
+      int rem = n % 2;
+      n /= 2;
+      if (prev == null || prev != rem) {
+        prev = rem;
+      } else {
+        return false;
+      }
     }
+    return true;
+  }
 }
diff --git a/README.md b/README.md
index 6c48b169..217b83c2 100644
--- a/README.md
+++ b/README.md
@@ -2,5 +2,5 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 750+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 800+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)

From d8c3283cd663279bc26f90dcf9a9674471e24e0f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 13 Nov 2020 08:32:53 -0600
Subject: [PATCH 0388/2175] Added Populating Next Right Pointers in Each
 Node.java

---
 ...ting Next Right Pointers in Each Node.java | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Medium/Populating Next Right Pointers in Each Node.java

diff --git a/Medium/Populating Next Right Pointers in Each Node.java b/Medium/Populating Next Right Pointers in Each Node.java
new file mode 100644
index 00000000..176deb77
--- /dev/null
+++ b/Medium/Populating Next Right Pointers in Each Node.java	
@@ -0,0 +1,41 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {}
+    
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
+*/
+
+class Solution {
+  public Node connect(Node root) {
+    Node prev = root;
+    Node curr = null;
+    while (prev != null && prev.left != null) {
+      curr = prev;
+      while (curr != null) {
+        curr.left.next = curr.right;
+        if (curr.next != null) {
+          curr.right.next = curr.next.left;
+        }
+        curr = curr.next;
+      }
+      prev = prev.left;
+    }
+    return root;
+  }
+}

From 540975ea48184bf0904c45a0689ff4322831a206 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 15 Nov 2020 09:46:23 -0600
Subject: [PATCH 0389/2175] Added Defuse the Bomb.java

---
 Easy/Defuse the Bomb.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Defuse the Bomb.java

diff --git a/Easy/Defuse the Bomb.java b/Easy/Defuse the Bomb.java
new file mode 100644
index 00000000..502f887c
--- /dev/null
+++ b/Easy/Defuse the Bomb.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int[] decrypt(int[] code, int k) {
+    int n = code.length;
+    int[] result = new int[n];
+    for (int i = 0; i < n; i++) {
+      if (k > 0) {
+        for (int j = i + 1; j < i + k + 1; j++) {
+          result[i] += code[j % n];
+        }
+      } else if (k < 0) {
+        for (int j = i - 1; j > i + k - 1; j--) {
+          result[i] += code[(j + n) % n];
+        }
+      }
+    }
+    return result;
+  }
+}

From 34ff11d9af801ca51a17d7e08fd5ed363f8b4c18 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 17 Nov 2020 09:47:00 -0800
Subject: [PATCH 0390/2175] Added Design an Ordered System.java

---
 Easy/Design an Ordered System.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Design an Ordered System.java

diff --git a/Easy/Design an Ordered System.java b/Easy/Design an Ordered System.java
new file mode 100644
index 00000000..e6427b9f
--- /dev/null
+++ b/Easy/Design an Ordered System.java	
@@ -0,0 +1,23 @@
+class OrderedStream {
+  int ptr;
+  String[] map;
+  public OrderedStream(int n) {
+    map = new String[n];
+    ptr = 0;
+  }
+
+  public List<String> insert(int id, String value) {
+    List<String> list = new ArrayList<>();
+    map[id - 1] = value;
+    while (ptr < map.length && map[ptr] != null) {
+      list.add(map[ptr++]);
+    }
+    return list;
+  }
+}
+
+/**
+ * Your OrderedStream object will be instantiated and called as such:
+ * OrderedStream obj = new OrderedStream(n);
+ * List<String> param_1 = obj.insert(id,value);
+ */

From 87789f855e46c0413bd6b52deefea812e86e6b81 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 22 Nov 2020 11:24:32 -0800
Subject: [PATCH 0391/2175] Added Check If Two String Arrays are
 Equivalent.java

---
 Easy/Check If Two String Arrays are Equivalent.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Easy/Check If Two String Arrays are Equivalent.java

diff --git a/Easy/Check If Two String Arrays are Equivalent.java b/Easy/Check If Two String Arrays are Equivalent.java
new file mode 100644
index 00000000..bbf06fcf
--- /dev/null
+++ b/Easy/Check If Two String Arrays are Equivalent.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
+    return Arrays.stream(word1).reduce((a, b) -> a + b)
+        .equals(Arrays.stream(word2).reduce((a, b) -> a + b));
+  }
+}

From bdd74d461720252a4e6bc8f005b2118af80026af Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 22 Nov 2020 14:49:21 -0800
Subject: [PATCH 0392/2175] Modified Unique Morse Code Words.java

---
 Easy/Unique Morse Code Words.java | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/Easy/Unique Morse Code Words.java b/Easy/Unique Morse Code Words.java
index 2db49a03..891a02b0 100644
--- a/Easy/Unique Morse Code Words.java	
+++ b/Easy/Unique Morse Code Words.java	
@@ -1,17 +1,14 @@
 class Solution {
+  private final String[] CODE = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
   public int uniqueMorseRepresentations(String[] words) {
-    String[] morseCodes = {
-      ".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",
-      ".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."
-    };
-    Set<String> set = new HashSet<>();
-    for (String word : words) {
-      StringBuilder sb = new StringBuilder();
-      for (char c : word.toCharArray()) {
-        sb.append(morseCodes[c - 'a']);
-      }
-      set.add(sb.toString());
+    return Arrays.stream(words).map(e -> getEncoding(e)).collect(Collectors.toSet()).size();
+  }
+  
+  private String getEncoding(String s) {
+    StringBuilder sb = new StringBuilder();
+    for (char c : s.toCharArray()) {
+      sb.append(CODE[c - 'a']);
     }
-    return set.size();
+    return sb.toString();
   }
 }

From b37c856fdc0d577d67b14f4525614a801034a24d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 23 Nov 2020 09:02:40 -0800
Subject: [PATCH 0393/2175] Added House Robber III.java

---
 Medium/House Robber III.java | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/House Robber III.java

diff --git a/Medium/House Robber III.java b/Medium/House Robber III.java
new file mode 100644
index 00000000..924423a9
--- /dev/null
+++ b/Medium/House Robber III.java	
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int rob(TreeNode root) {
+    int[] ans = helper(root);
+    return Math.max(ans[0], ans[1]);
+  }
+  
+  private int[] helper(TreeNode root) {
+    if (root == null) {
+      return new int[]{0, 0};
+    }
+    int[] left = helper(root.left);
+    int[] right = helper(root.right);
+    int robbed = root.val + left[1] + right[1];
+    int notRobbed = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
+    return new int[]{robbed, notRobbed};
+  }
+}

From f1d1256821bd06475e6159c9a3ddb0dd92e121bb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 24 Nov 2020 07:02:33 -0800
Subject: [PATCH 0394/2175] Refactored Basic Calculator II.java

---
 Medium/Basic Calculator II.java | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Medium/Basic Calculator II.java b/Medium/Basic Calculator II.java
index da6ae5e4..470ec88c 100644
--- a/Medium/Basic Calculator II.java	
+++ b/Medium/Basic Calculator II.java	
@@ -1,34 +1,31 @@
 class Solution {
   public int calculate(String s) {
-    Stack<Integer> stack = new Stack<>();
     int num = 0;
     char sign = '+';
+    Stack<Integer> stack = new Stack<>();
     for (int i = 0; i < s.length(); i++) {
       char c = s.charAt(i);
       if (Character.isDigit(c)) {
         num = num * 10 + Character.getNumericValue(c);
-      }
+      } 
       if (!Character.isDigit(c) && c != ' ' || i == s.length() - 1) {
-        if (sign == '-') {
-          stack.push(-num);
-        }
-        else if (sign == '+') {
+        if (sign == '+') {
           stack.push(num);
-        }
-        else if (sign == '*') {
+        } else if (sign == '-') {
+          stack.push(-num);
+        } else if (sign == '*') {
           stack.push(stack.pop() * num);
-        }
-        else {
+        } else {
           stack.push(stack.pop() / num);
         }
         sign = c;
         num = 0;
       }
     }
-    int res = 0;
+    int result = 0;
     while (!stack.isEmpty()) {
-      res += stack.pop();
+      result += stack.pop();
     }
-    return res;
+    return result;
   }
 }

From e52b4055af91d9842252012ac0c80c98a0c5029f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 24 Nov 2020 07:12:10 -0800
Subject: [PATCH 0395/2175] Added Smallest String With A Given Numeric
 Value.java

---
 ...mallest String With A Given Numeric Value.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Smallest String With A Given Numeric Value.java

diff --git a/Medium/Smallest String With A Given Numeric Value.java b/Medium/Smallest String With A Given Numeric Value.java
new file mode 100644
index 00000000..929b7ade
--- /dev/null
+++ b/Medium/Smallest String With A Given Numeric Value.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public String getSmallestString(int n, int k) {
+    StringBuilder sb = new StringBuilder();
+    for (int idx = 0; idx < n; idx++) {
+      for (int currChar = 26; currChar > 0; currChar--) {
+        if (currChar <= k && k - currChar >= (n - idx - 1)) {
+          sb.append((char) (97 + currChar - 1));
+          k -= currChar;
+          break;
+        }
+      }
+    }
+    return sb.reverse().toString();
+  }
+}

From e07f3de79b7b0241d63e174db261c45fe10a865c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 25 Nov 2020 07:00:24 -0800
Subject: [PATCH 0396/2175] Added Smallest Integer Divisible by K.java

---
 Medium/Smallest Integer Divisible by K.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Smallest Integer Divisible by K.java

diff --git a/Medium/Smallest Integer Divisible by K.java b/Medium/Smallest Integer Divisible by K.java
new file mode 100644
index 00000000..52575545
--- /dev/null
+++ b/Medium/Smallest Integer Divisible by K.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int smallestRepunitDivByK(int K) {
+    if (K % 2 == 0 || K % 5 == 0) {
+      return -1;
+    }
+    int remainder = 0;
+    for (int n = 1; n <= K; n++) {
+      remainder = (remainder * 10 + 1) % K;
+      if (remainder == 0) {
+        return n;
+      }
+    }
+    return -1;
+  }
+}

From fcc8b4e435b1014be35ec4d2b7b87d20476e161f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 28 Nov 2020 17:36:19 -0800
Subject: [PATCH 0397/2175] Added Maximum Repeating Substring.java

---
 Easy/Maximum Repeating Substring.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Maximum Repeating Substring.java

diff --git a/Easy/Maximum Repeating Substring.java b/Easy/Maximum Repeating Substring.java
new file mode 100644
index 00000000..9b1ae019
--- /dev/null
+++ b/Easy/Maximum Repeating Substring.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int maxRepeating(String sequence, String word) {
+    int maxCount = 0;
+    int idx = 0;
+    int wordLength = word.length();
+    int limitLength = sequence.length() - wordLength + 1;
+    while (idx < limitLength) {
+      int currCount = 0;
+      while (idx < limitLength && sequence.substring(idx, idx + wordLength).equals(word)) {
+        currCount++;
+        idx += wordLength;
+      }
+      maxCount = Math.max(maxCount, currCount);
+      idx++;
+    }
+    return maxCount;
+  } 
+}

From fae9734f2ac905216f9e9d7674177a145051bc78 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 29 Nov 2020 08:09:54 -0800
Subject: [PATCH 0398/2175] Added Richest Customer Wealth.java

---
 Easy/Richest Customer Wealth.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Richest Customer Wealth.java

diff --git a/Easy/Richest Customer Wealth.java b/Easy/Richest Customer Wealth.java
new file mode 100644
index 00000000..e7ff34dc
--- /dev/null
+++ b/Easy/Richest Customer Wealth.java	
@@ -0,0 +1,8 @@
+class Solution {
+  public int maximumWealth(int[][] accounts) {
+    return Arrays.stream(accounts)
+        .map(e -> Arrays.stream(e).sum())
+        .max(Integer::compareTo)
+        .orElse(0);
+  }
+}

From 831fb7cf489241e85cdb0770a78233d2b0ba39f5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 30 Nov 2020 18:28:52 -0800
Subject: [PATCH 0399/2175] Added Merge In Between Linked Lists.java

---
 Medium/Merge In Between Linked Lists.java | 35 +++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 Medium/Merge In Between Linked Lists.java

diff --git a/Medium/Merge In Between Linked Lists.java b/Medium/Merge In Between Linked Lists.java
new file mode 100644
index 00000000..5e3b814a
--- /dev/null
+++ b/Medium/Merge In Between Linked Lists.java	
@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
+    ListNode currList1 = list1;
+    // Stop just before a and record the pointer
+    for (int i = 0; i < a - 1; i++) {
+      currList1 = currList1.next;
+    }
+    ListNode currCopy = currList1;
+    // Cover a to b
+    for (int i = a; i <= b; i++) {
+      currList1 = currList1.next;
+    } 
+    // Record what is remaining after b
+    ListNode remaining = currList1.next;
+    // Find end of list2
+    ListNode list2End = list2;
+    while (list2End != null && list2End.next != null) {
+      list2End = list2End.next;
+    }
+    // Pointer manipulation
+    currCopy.next = list2;
+    list2End.next = remaining;
+    return list1;
+  }
+}

From b1800cf48834a9666f951357fa92fc40e623a2b0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 3 Dec 2020 07:37:14 -0800
Subject: [PATCH 0400/2175] Refactored Increasing Order Search Tree.java

---
 Easy/Increasing Order Search Tree.java | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/Easy/Increasing Order Search Tree.java b/Easy/Increasing Order Search Tree.java
index 4039276d..93e003f3 100644
--- a/Easy/Increasing Order Search Tree.java	
+++ b/Easy/Increasing Order Search Tree.java	
@@ -4,7 +4,13 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {

From afd821124100ad7e6f6a21de50c3826bf7042d5f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 3 Dec 2020 23:46:08 -0800
Subject: [PATCH 0401/2175] Added Sort the Matrix Diagonally.java

---
 Medium/Sort the Matrix Diagonally.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Sort the Matrix Diagonally.java

diff --git a/Medium/Sort the Matrix Diagonally.java b/Medium/Sort the Matrix Diagonally.java
new file mode 100644
index 00000000..f0ec13f3
--- /dev/null
+++ b/Medium/Sort the Matrix Diagonally.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int[][] diagonalSort(int[][] mat) {
+    Map<Integer, PriorityQueue<Integer>> map = new HashMap<>();
+    for (int i = 0; i < mat.length; i++) {
+      for (int j = 0; j < mat[0].length; j++) {
+        map.computeIfAbsent(i - j, k -> new PriorityQueue<>()).add(mat[i][j]);
+      }
+    }
+    for (int i = 0; i < mat.length; i++) {
+      for (int j = 0; j < mat[0].length; j++) {
+        mat[i][j] = map.get(i - j).poll();
+      }
+    }
+    return mat;
+  }
+}

From 6f99722e9956f846e87b5471924427ddaa5d0691 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 4 Dec 2020 07:55:53 -0800
Subject: [PATCH 0402/2175] Added The kth Factor of n.java

---
 Medium/The kth Factor of n.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Medium/The kth Factor of n.java

diff --git a/Medium/The kth Factor of n.java b/Medium/The kth Factor of n.java
new file mode 100644
index 00000000..046b3293
--- /dev/null
+++ b/Medium/The kth Factor of n.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public int kthFactor(int n, int k) {
+    for (int i = 1; i <= n / 2; i++) {
+      if (n % i == 0 && --k == 0) {
+        return i;
+      }
+    }
+    return k == 1 ? n : -1;
+  }
+}

From 70cb7387042177d03504d7f3ef8f0c53f6159fbf Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 6 Dec 2020 15:06:30 -0800
Subject: [PATCH 0403/2175] Added Goal Parser Interpretation.java

---
 Easy/Goal Parser Interpretation.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Goal Parser Interpretation.java

diff --git a/Easy/Goal Parser Interpretation.java b/Easy/Goal Parser Interpretation.java
new file mode 100644
index 00000000..f5c1fb24
--- /dev/null
+++ b/Easy/Goal Parser Interpretation.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public String interpret(String command) {
+    StringBuilder sb = new StringBuilder();
+    int idx = 0;
+    while (idx < command.length()) {
+      if (command.charAt(idx) == '(') {
+        if (command.charAt(idx + 1) == ')') {
+          sb.append('o');
+          idx++;
+        } else {
+          idx++;
+          while (command.charAt(idx) != ')') {
+            sb.append(command.charAt(idx++));
+          }
+        }
+        idx++;
+      } else {
+        sb.append(command.charAt(idx++));
+      }
+    }
+    return sb.toString();
+  }
+}

From f22ccd3f0cd1ed23160ebe672be7b0b929c9b615 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 7 Dec 2020 07:28:48 -0800
Subject: [PATCH 0404/2175] Added Max Number of K-Sum Pairs.java

---
 Medium/Max Number of K-Sum Pairs.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Max Number of K-Sum Pairs.java

diff --git a/Medium/Max Number of K-Sum Pairs.java b/Medium/Max Number of K-Sum Pairs.java
new file mode 100644
index 00000000..1669f456
--- /dev/null
+++ b/Medium/Max Number of K-Sum Pairs.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int maxOperations(int[] nums, int k) {
+    Map<Integer, Integer> counter = new HashMap<>();
+    for (int num : nums) {
+      counter.put(num, counter.getOrDefault(num, 0) + 1);
+    }
+    Set<Integer> keys = counter.keySet();
+    int numOfPairs = 0;
+    for (Integer key : keys) {
+      if (counter.containsKey(k - key) && (k - key != key)) {
+        int min = Math.min(counter.get(key), counter.get(k - key));
+        counter.put(key, counter.get(key) - min);
+        counter.put(k - key, counter.get(k - key) - min);
+        numOfPairs += min;
+      } else if (counter.containsKey(k - key) && (k - key == key)) {
+        numOfPairs += counter.get(key) / 2;
+        counter.put(key, counter.get(key) / 2);
+      }
+    }
+    return numOfPairs;
+  }
+}

From b8cedef952b9379b0eedacc677357e2c681e81f7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 9 Dec 2020 06:56:02 -0800
Subject: [PATCH 0405/2175] Refactored Binary Search Tree Iterator.java

---
 Medium/Binary Search Tree Iterator.java | 23 ++++++++---------------
 1 file changed, 8 insertions(+), 15 deletions(-)

diff --git a/Medium/Binary Search Tree Iterator.java b/Medium/Binary Search Tree Iterator.java
index 038f4a37..28e6aaa4 100644
--- a/Medium/Binary Search Tree Iterator.java	
+++ b/Medium/Binary Search Tree Iterator.java	
@@ -17,29 +17,22 @@ class BSTIterator {
   Stack<TreeNode> stack;
   public BSTIterator(TreeNode root) {
     stack = new Stack<>();
-    update(root);
-  }
-  
-  private void update(TreeNode node) {
-    if (node == null) {
-      return;
-    }
-    stack.add(node);
-    TreeNode leftNode = node.left;
-    while (leftNode != null) {
-      stack.add(leftNode);
-      leftNode = leftNode.left;
+    while (root != null) {
+      stack.push(root);
+      root = root.left;
     }
   }
 
-  /** @return the next smallest number */
   public int next() {
     TreeNode node = stack.pop();
-    update(node.right);
+    TreeNode rightNode = node.right;
+    while (rightNode != null) {
+      stack.push(rightNode);
+      rightNode = rightNode.left;
+    }
     return node.val;
   }
 
-  /** @return whether we have a next smallest number */
   public boolean hasNext() {
     return !stack.isEmpty();
   }

From ac5ecb098e53644f1e2ca11047b28da8cb2b96cc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Dec 2020 07:02:45 -0800
Subject: [PATCH 0406/2175] Refactored Remove Duplicates From Sorted Array
 II.java

---
 ...emove Duplicates From Sorted Array II.java | 43 ++++++++-----------
 1 file changed, 17 insertions(+), 26 deletions(-)

diff --git a/Medium/Remove Duplicates From Sorted Array II.java b/Medium/Remove Duplicates From Sorted Array II.java
index 2ed32e65..90a056c7 100644
--- a/Medium/Remove Duplicates From Sorted Array II.java	
+++ b/Medium/Remove Duplicates From Sorted Array II.java	
@@ -1,29 +1,20 @@
 class Solution {
-    public int removeDuplicates(int[] nums) {
-        return removeDuplicatesUtil(nums, nums.length, 2);
-    }
-    
-    private int removeDuplicatesUtil(int[] nums, int n, int k) {
-        if (n <= k) return n;
-        
-        int i = 1;
-        int j = 1;
-        int cnt = 1;
-        
-        while (j < n) {
-            if (nums[j] != nums[j-1]) {
-                cnt = 1;
-                nums[i++] = nums[j];
-            }
-            else {
-                if (cnt < k) {
-                    nums[i++] = nums[j];
-                    cnt++;
-                }
-            }
-            ++j;
-        }
-        
-        return i;
+  public int removeDuplicates(int[] nums) {
+    int slow = 0;
+    int fast = 0;
+    int n = nums.length;
+    while (fast < n) {
+      int currNum = nums[fast];
+      int count = 0;
+      while (fast < n && currNum == nums[fast]) {
+        fast++;
+        count++;
+      }
+      int frequency = Math.min(count, 2);
+      while (frequency-- > 0) {
+        nums[slow++] = currNum;
+      }
     }
+    return slow;
+  }
 }

From 51784c4250848004759a929a5bf949c76e731e7a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 12 Dec 2020 12:39:01 -0800
Subject: [PATCH 0407/2175] Added Count the Number of Consistent Strings.java

---
 Easy/Count the Number of Consistent Strings.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Count the Number of Consistent Strings.java

diff --git a/Easy/Count the Number of Consistent Strings.java b/Easy/Count the Number of Consistent Strings.java
new file mode 100644
index 00000000..24aad751
--- /dev/null
+++ b/Easy/Count the Number of Consistent Strings.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public int countConsistentStrings(String allowed, String[] words) {
+    return (int)
+        Arrays.stream(words)
+            .filter(
+                word ->
+                    word.chars().mapToObj(c -> (char) c).allMatch(c -> allowed.indexOf(c) != -1))
+            .count();
+  }
+}

From 174de1105f98816f3dc0e86da53d61397fbab201 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 13 Dec 2020 06:26:31 -0800
Subject: [PATCH 0408/2175] Added Count of Matches in Tournament.java

---
 Easy/Count of Matches in Tournament.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Count of Matches in Tournament.java

diff --git a/Easy/Count of Matches in Tournament.java b/Easy/Count of Matches in Tournament.java
new file mode 100644
index 00000000..1fc5a6e4
--- /dev/null
+++ b/Easy/Count of Matches in Tournament.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public int numberOfMatches(int n) {
+    int numOfMatches = 0;
+    while (n > 1) {
+      numOfMatches += n / 2;
+      n = n / 2 + n % 2;
+    }
+    return numOfMatches;
+  }
+}

From 5dc66deefd00fade67736d48385a9becc570bd54 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 13 Dec 2020 11:00:46 -0800
Subject: [PATCH 0409/2175] Added Sum of Absolute Differences in a Sorted
 Array.java

---
 ...bsolute Differences in a Sorted Array.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Sum of Absolute Differences in a Sorted Array.java

diff --git a/Medium/Sum of Absolute Differences in a Sorted Array.java b/Medium/Sum of Absolute Differences in a Sorted Array.java
new file mode 100644
index 00000000..de0e5920
--- /dev/null
+++ b/Medium/Sum of Absolute Differences in a Sorted Array.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int[] getSumAbsoluteDifferences(int[] nums) {
+    int n = nums.length;
+    int[] answer = new int[n];
+    int[] leftToRightSum = new int[n];
+    int[] rightToLeftSum = new int[n];
+    int currSum = 0;
+    for (int i = 0; i < n; i++) {
+      currSum += nums[i];
+      leftToRightSum[i] = currSum;
+    }
+    currSum = 0;
+    for (int i = n - 1; i >= 0; i--) {
+      currSum += nums[i];
+      rightToLeftSum[i] = currSum;
+    }
+    for (int i = 0; i < n; i++) {
+      answer[i] = (i == 0 ? 0 : i * nums[i] - leftToRightSum[i - 1]) + (i == n - 1 ? 0 : (rightToLeftSum[i + 1] - (n - 1 - i) * nums[i]));
+    }
+    return answer;
+  }
+}

From 1c3294c8dd4333a15b65702e97c28e23cf44a14a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 14 Dec 2020 12:59:55 -0800
Subject: [PATCH 0410/2175] Added Partitioning Into Minimum Number Of
 Deci-Binary Numbers.java

---
 ...oning Into Minimum Number Of Deci-Binary Numbers.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Medium/Partitioning Into Minimum Number Of Deci-Binary Numbers.java

diff --git a/Medium/Partitioning Into Minimum Number Of Deci-Binary Numbers.java b/Medium/Partitioning Into Minimum Number Of Deci-Binary Numbers.java
new file mode 100644
index 00000000..4ede9af8
--- /dev/null
+++ b/Medium/Partitioning Into Minimum Number Of Deci-Binary Numbers.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public int minPartitions(String n) {
+    return n.chars()
+            .mapToObj(c -> (char) c)
+            .mapToInt(Character::getNumericValue)
+            .reduce(Integer::max)
+            .orElse(0);
+  }
+}

From fa65f3ebcecc68e337739930d2cc6585c3724675 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 15 Dec 2020 07:40:57 -0800
Subject: [PATCH 0411/2175] Refactored Squares of a Sorted Array.java

---
 Easy/Squares of a Sorted Array.java | 46 ++++++++++++-----------------
 1 file changed, 19 insertions(+), 27 deletions(-)

diff --git a/Easy/Squares of a Sorted Array.java b/Easy/Squares of a Sorted Array.java
index efd36968..1658e567 100644
--- a/Easy/Squares of a Sorted Array.java	
+++ b/Easy/Squares of a Sorted Array.java	
@@ -1,35 +1,27 @@
 class Solution {
-  public int[] sortedSquares(int[] A) {
-    int posIdx = A.length;
-    for (int i = 0; i < A.length; i++) {
-      if (A[i] >= 0) {
-        posIdx = i;
-        break;
-      }
+  public int[] sortedSquares(int[] nums) {
+    int n = nums.length;
+    int[] squareSorted = new int[n];
+    int start = 0;
+    while (start < n && nums[start] < 0) {
+      start++;
     }
-    int[] ans = new int[A.length];
-    int negIdx = posIdx - 1;
+    int end = start;
+    start -= 1;
     int idx = 0;
-    while (negIdx >= 0 || posIdx < A.length) {
-      if (negIdx >= 0 && (posIdx >= 0 && posIdx < A.length)) {
-        if (A[negIdx] * A[negIdx] > A[posIdx] * A[posIdx]) {
-          ans[idx++] = A[posIdx] * A[posIdx];
-          posIdx++;
-        }
-        else {
-          ans[idx++] = A[negIdx] * A[negIdx];
-          negIdx--;
+    while (start >= 0 || end < n) {
+      if (start >= 0 && end < n) {
+        if (nums[start] * nums[start] > nums[end] * nums[end]) {
+          squareSorted[idx++] = nums[end] * nums[end++];
+        } else {
+          squareSorted[idx++] = nums[start] * nums[start--];
         }
-      }
-      else if (negIdx >= 0 && posIdx >= A.length) {
-        ans[idx++] = A[negIdx] * A[negIdx];
-        negIdx--;
-      }
-      else {
-        ans[idx++] = A[posIdx] * A[posIdx];
-        posIdx++;
+      } else if (start >= 0) {
+        squareSorted[idx++] = nums[start] * nums[start--];
+      } else {
+          squareSorted[idx++] = nums[end] * nums[end++];
       }
     }
-    return ans;
+    return squareSorted;
   }
 }

From 2e3e762ee876bad79cf2a5b8da32d57721ea3719 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 15 Dec 2020 15:13:20 -0800
Subject: [PATCH 0412/2175] Refactored Design Twitter.java

---
 Medium/Design Twitter.java | 232 ++++++++++++++-----------------------
 1 file changed, 90 insertions(+), 142 deletions(-)

diff --git a/Medium/Design Twitter.java b/Medium/Design Twitter.java
index 65b71c71..cd5361e2 100644
--- a/Medium/Design Twitter.java	
+++ b/Medium/Design Twitter.java	
@@ -1,160 +1,108 @@
 class Twitter {
 
-    /** Initialize your data structure here. */
-    Map<Integer, User> userMap;
-    Map<User, List<User>> followingMap;
-    Map<User, List<User>> followerMap;
-    int tweetTimeStamp;
-
-    public Twitter() {
-        followingMap = new HashMap<>();
-        userMap = new HashMap<>();
-        followerMap = new HashMap<>();
-        tweetTimeStamp = 0;
+  /** Initialize your data structure here. */
+  Map<Integer, User> userMap;
+
+  int tweetTimeStamp;
+
+  public Twitter() {
+    userMap = new HashMap<>();
+    tweetTimeStamp = 0;
+  }
+
+  /** Compose a new tweet. */
+  public void postTweet(int userId, int tweetId) {
+    createUserIfNotExist(userId);
+    userMap.get(userId).addTweet(tweetId, tweetTimeStamp++);
+  }
+
+  /**
+   * Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must
+   * be posted by users who the user followed or by the user herself. Tweets must be ordered from
+   * most recent to least recent.
+   */
+  public List<Integer> getNewsFeed(int userId) {
+    createUserIfNotExist(userId);
+    List<User> usersFollowed =
+        userMap.get(userId).following.stream()
+            .map(e -> userMap.get(e))
+            .collect(Collectors.toList());
+    return userMap.get(userId).getFeed(usersFollowed);
+  }
+
+  /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
+  public void follow(int followerId, int followeeId) {
+    if (followerId != followeeId) {
+      createUserIfNotExist(followerId);
+      createUserIfNotExist(followeeId);
+      userMap.get(followerId).following.add(followeeId);
     }
-
-    /** Compose a new tweet. */
-    public void postTweet(int userId, int tweetId) {
-        Tweet tweet = new Tweet(tweetId, userId, tweetTimeStamp);
-        tweetTimeStamp++;
-
-        createUserIfAbsent(userId);
-
-        userMap.get(userId).topTweets.add(tweet);
-        List<User> followers = followerMap.getOrDefault(userMap.get(userId), new ArrayList<>());
-        for (User follower : followers) {
-            follower.topTweets.add(tweet);
-        }
+  }
+
+  /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
+  public void unfollow(int followerId, int followeeId) {
+    if (followerId != followeeId) {
+      createUserIfNotExist(followerId);
+      createUserIfNotExist(followeeId);
+      userMap.get(followerId).following.remove(followeeId);
     }
+  }
 
-    /** Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent. */
-    public List<Integer> getNewsFeed(int userId) {
-        if (!userMap.containsKey(userId)) {
-            return new ArrayList<>();
-        }
-
-        List<Integer> topTweetIds = new ArrayList<>();
-        Set<Integer> tweetIdSet = new HashSet<>();
-        List<Tweet> topTweets = new ArrayList<>();
-
-        PriorityQueue<Tweet> pq = userMap.get(userId).topTweets;
-        int count = 10;
-
-        while (count > 0 && !pq.isEmpty()) {
-            Tweet tweet = pq.poll();
-            topTweets.add(tweet);
-
-            List<User> usersFollowing = followingMap.get(userMap.get(userId));
-
-            if ((userMap.containsKey(tweet.userId) && usersFollowing.contains(userMap.get(tweet.userId))) ||
-                tweet.userId == userId) {
-                if (!tweetIdSet.contains(tweet.tweetId)) {
-                    topTweetIds.add(tweet.tweetId);
-                    tweetIdSet.add(tweet.tweetId);
-                    count--;
-                }
-            }
-        }
-
-        pq.addAll(topTweets);
-
-        return topTweetIds;
-    }
-
-    /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
-    public void follow(int followerId, int followeeId) {
-        if (followeeId == followerId) {
-            return;
-        }
-
-        createUserIfAbsent(followeeId);
-        createUserIfAbsent(followerId);
-
-        if (!followingMap.get(userMap.get(followerId)).contains(userMap.get(followeeId))) {
-            followingMap.get(userMap.get(followerId)).add(userMap.get(followeeId));
-            userMap.get(followerId).topTweets.addAll(userMap.get(followeeId).topTweets);
-        }
-
-        if (!followerMap.getOrDefault(userMap.get(followeeId), new ArrayList<>()).contains(userMap.get(followerId))) {
-            followerMap.get(userMap.get(followeeId)).add(userMap.get(followerId));
-        }
-
-    }
-
-    private void createUserIfAbsent(int id) {
-        if (!userMap.containsKey(id)) {
-            User newUser = new User(id);
-            userMap.put(id, newUser);
-            List<User> followers = new ArrayList<>();
-            List<User> following = new ArrayList<>();
-
-            followingMap.put(newUser, following);
-            followerMap.put(newUser, followers);
-        }
-    }
-
-    /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
-    public void unfollow(int followerId, int followeeId) {
-        if (!userMap.containsKey(followeeId)) {
-            return;
-        }
-
-        if (!userMap.containsKey(followerId)) {
-            return;
-        }
-
-        if (followingMap.get(userMap.get(followerId)).contains(userMap.get(followeeId))) {
-            followingMap.get(userMap.get(followerId)).remove(userMap.get(followeeId));
-        }
-    }
+  private void createUserIfNotExist(int userId) {
+    userMap.computeIfAbsent(userId, k -> new User(userId));
+  }
 }
 
 class User {
-    public int id;
-    public List<Integer> followers;
-    PriorityQueue<Tweet> topTweets;
-
-    public User(int id) {
-        this.id = id;
-        this.followers = new ArrayList<>();
-        this.topTweets = new PriorityQueue<>(new Comparator<Tweet>() {
-            @Override
-            public int compare(Tweet o1, Tweet o2) {
-                return o2.timestamp - o1.timestamp;
-            }
-        });
-    }
-
-    @Override
-    public String toString() {
-        return "User{" +
-                "id=" + id +
-                '}';
+  int id;
+  Set<Integer> following;
+  PriorityQueue<Tweet> tweets;
+
+  public User(int id) {
+    this.id = id;
+    following = new HashSet<>();
+    tweets = new PriorityQueue<>((t1, t2) -> t2.timestamp - t1.timestamp);
+  }
+
+  public void addTweet(int tweetId, int timestamp) {
+    tweets.add(new Tweet(tweetId, timestamp));
+  }
+
+  public List<Integer> getFeed(List<User> usersFollowed) {
+    PriorityQueue<PriorityQueue<Tweet>> allTweets =
+        new PriorityQueue<>(
+            (t1, t2) -> {
+              if (t2.peek() != null) {
+                return t2.peek().timestamp - (t1.peek() != null ? t1.peek().timestamp : 0);
+              }
+              return 0;
+            });
+    usersFollowed.add(this);
+    usersFollowed.stream()
+        .filter(user -> !user.tweets.isEmpty())
+        .forEach(user -> allTweets.add(new PriorityQueue<>(user.tweets)));
+    List<Integer> feed = new ArrayList<>();
+    while (feed.size() < 10 && !allTweets.isEmpty()) {
+      PriorityQueue<Tweet> removed = allTweets.remove();
+      feed.add(removed.poll().id);
+      if (!removed.isEmpty()) {
+        allTweets.add(removed);
+      }
     }
+    return feed;
+  }
 }
 
 class Tweet {
-    public int tweetId;
-    public int userId;
-    public int timestamp;
-
-    public Tweet(int tweetId, int userId, int timestamp) {
-        this.tweetId = tweetId;
-        this.userId = userId;
-        this.timestamp = timestamp;
-    }
+  int id;
+  int timestamp;
 
-    @Override
-    public String toString() {
-        return "Tweet{" +
-                "tweetId=" + tweetId +
-                ", userId=" + userId +
-                '}';
-    }
+  public Tweet(int id, int timestamp) {
+    this.id = id;
+    this.timestamp = timestamp;
+  }
 }
 
-
-
 /**
  * Your Twitter object will be instantiated and called as such:
  * Twitter obj = new Twitter();

From 46ba87a1694e2fa4fda37a5f9a674b29372bc8d5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 17 Dec 2020 08:09:48 -0800
Subject: [PATCH 0413/2175] Added 4Sum II.java

---
 Medium/4Sum II.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/4Sum II.java

diff --git a/Medium/4Sum II.java b/Medium/4Sum II.java
new file mode 100644
index 00000000..ecd8f47b
--- /dev/null
+++ b/Medium/4Sum II.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
+    int n = A.length;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        map.put(A[i] + B[j], map.getOrDefault(A[i] + B[j], 0) + 1);
+      }
+    }
+    int count = 0;
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        count += map.getOrDefault(-1 * (C[i] + D[j]), 0);
+      }
+    }
+    return count;
+  }
+}

From 82c3c05883a4003cf2fe6e881fb1ccb1daf561db Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 20 Dec 2020 07:30:49 -0800
Subject: [PATCH 0414/2175] Added Reformat Phone Number.java

---
 Easy/Reformat Phone Number.java | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Easy/Reformat Phone Number.java

diff --git a/Easy/Reformat Phone Number.java b/Easy/Reformat Phone Number.java
new file mode 100644
index 00000000..a2f9dfa6
--- /dev/null
+++ b/Easy/Reformat Phone Number.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public String reformatNumber(String number) {
+    List<Character> digits = number.chars().mapToObj(c -> (char) c).filter(Character::isDigit)
+        .collect(Collectors.toList());
+    StringBuilder sb = new StringBuilder();
+    int remainingCharacter = digits.size();
+    int idx = 0;
+    while (remainingCharacter > 4) {
+      for (int i = 0; i < 3; i++) {
+        sb.append(digits.get(idx++));
+      }
+      remainingCharacter -= 3;
+      sb.append("-");
+    }
+    if (remainingCharacter > 3) {
+      for (int i = 0; i < 4; i++) {
+        sb.append(digits.get(idx++));
+        if (i == 1) {
+          sb.append('-');
+        }
+      }
+    } else {
+      for (; idx < digits.size(); idx++) {
+        sb.append(digits.get(idx));
+      }
+    }
+    return sb.toString();
+  }
+}

From 497b2642d3c65c6f8850536fa8a57e105559b004 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 20 Dec 2020 11:15:46 -0800
Subject: [PATCH 0415/2175] Added Maximum Erasure Value.java

---
 Medium/Maximum Erasure Value.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Maximum Erasure Value.java

diff --git a/Medium/Maximum Erasure Value.java b/Medium/Maximum Erasure Value.java
new file mode 100644
index 00000000..ff897923
--- /dev/null
+++ b/Medium/Maximum Erasure Value.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int maximumUniqueSubarray(int[] nums) {
+    int maximumSum = 0;
+    int currSum = 0;
+    int start = 0;
+    int end = 0;
+    int n = nums.length;
+    Map<Integer, Integer> map = new HashMap<>();
+    while (end < n) {
+      int currNum = nums[end++];
+      map.put(currNum, map.getOrDefault(currNum, 0) + 1);
+      currSum += currNum;
+      while (start < end && map.get(currNum) > 1) {
+        map.put(nums[start], map.getOrDefault(nums[start], 0) - 1);
+        currSum -= nums[start++];
+      }
+      maximumSum = Math.max(maximumSum, currSum);
+    }
+    return maximumSum;
+  }
+}

From 39f5eb9204aa8f2f0c6ff5574ac305c0e2ec0da3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 22 Dec 2020 15:41:47 -0800
Subject: [PATCH 0416/2175] Refactored Balanced Binary Tree.java

---
 Easy/Balanced Binary Tree.java | 43 +++++++++++++++++++++++-----------
 1 file changed, 29 insertions(+), 14 deletions(-)

diff --git a/Easy/Balanced Binary Tree.java b/Easy/Balanced Binary Tree.java
index 99084872..fb3ea347 100644
--- a/Easy/Balanced Binary Tree.java	
+++ b/Easy/Balanced Binary Tree.java	
@@ -4,23 +4,38 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public boolean isBalanced(TreeNode root) {
-        if (root == null) return true;
-        
-        int lh = height(root.left);
-        int rh = height(root.right);
-        
-        return Math.abs(lh-rh) <= 1 && isBalanced(root.left) && isBalanced(root.right);
+  public boolean isBalanced(TreeNode root) {
+    if (root == null) {
+      return true;
     }
-    
-    public int height(TreeNode root) {
-        if(root == null) return 0;
-        
-        return 1 + Math.max(height(root.left), height(root.right));
+    Map<TreeNode, Integer> map = new HashMap<>();
+    int leftHeight = getHeight(root.left, map);
+    int rightHeight = getHeight(root.right, map);
+    if (Math.abs(leftHeight - rightHeight) > 1) {
+      return false;
     }
-    
+    return isBalanced(root.left) && isBalanced(root.right);
+  }
+  
+  private int getHeight(TreeNode root, Map<TreeNode, Integer> map) {
+    if (root == null) {
+      return 0;
+    }
+    if (map.containsKey(root)) {
+      return map.get(root);
+    }
+    int height = 1 + Math.max(getHeight(root.left, map), getHeight(root.right, map));
+    map.put(root, height);
+    return height;
+  }
 }

From 5f511d1405b5c5a58803b9b035d6e35edc83a79d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 23 Dec 2020 16:41:57 -0800
Subject: [PATCH 0417/2175] Refactored Next Greater Element III.java

---
 Medium/Next Greater Element III.java | 76 ++++++++++------------------
 1 file changed, 28 insertions(+), 48 deletions(-)

diff --git a/Medium/Next Greater Element III.java b/Medium/Next Greater Element III.java
index 0d0592ef..92d84436 100644
--- a/Medium/Next Greater Element III.java	
+++ b/Medium/Next Greater Element III.java	
@@ -1,53 +1,33 @@
 class Solution {
-    public int nextGreaterElement(int n) {
-        int[] arr = getArr(n);
-        int i;
-        for (i=arr.length-1; i>0; i--) {
-            if (arr[i-1] < arr[i]) {
-                break;
-            }
+  public int nextGreaterElement(int n) {
+    char[] digits = String.valueOf(n).toCharArray();
+    int idx = digits.length - 2;
+    while (idx >= 0) {
+      if (Character.getNumericValue(digits[idx]) < Character.getNumericValue(digits[idx + 1])) {
+        int secondIdx = digits.length - 1;
+        while (secondIdx >= idx && digits[secondIdx] <= digits[idx]) {
+          secondIdx--;
+        } 
+        swap(digits, idx, secondIdx);
+        int start = idx + 1;
+        int end = digits.length - 1;
+        while (start < end) {
+          swap(digits, start++, end--);
         }
-
-        if (i == 0) {
-            return -1;
+        try {
+          return Integer.parseInt(new String(digits));
+        } catch (Exception e) {
+          return -1;
         }
-
-        int num = arr[i-1];
-        int small = i;
-        for (int j=i+1; j<arr.length; j++) {
-            if (arr[j] > num && arr[j] <= arr[small]) {
-                small = j;
-            }
-        }
-
-        int temp = arr[i-1];
-        arr[i-1] = arr[small];
-        arr[small] = temp;
-
-        Arrays.sort(arr, i, arr.length);
-        long ans = getNumber(arr);
-        
-        return ans <= Integer.MAX_VALUE ? (int) ans : -1;
-    }
-
-    private long getNumber(int[] arr) {
-        long num = 0;
-        for (int i=0; i<arr.length; i++) {
-            num = num * 10 + arr[i];
-        }
-
-        return num;
-    }
-
-    private int[] getArr(int n) {
-        int[] arr = new int[String.valueOf(n).length()];
-        int i = arr.length - 1;
-        while (i >= 0) {
-            arr[i] = n % 10;
-            n /= 10;
-            i--;
-        }
-
-        return arr;
+      }
+      idx--;
     }
+    return -1;
+  }
+  
+  private void swap(char[] digits, int idxOne, int idxTwo) {
+    char temp = digits[idxOne];
+    digits[idxOne] = digits[idxTwo];
+    digits[idxTwo] = temp;
+  }
 }

From 076d848703eff657ee2fd5789203c569f2588ffb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 24 Dec 2020 12:03:23 -0800
Subject: [PATCH 0418/2175] Refactored Swap Nodes in Pairs.java

---
 Medium/Swap Nodes in Pair.java  | 29 -----------------------------
 Medium/Swap Nodes in Pairs.java | 30 ++++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 29 deletions(-)
 delete mode 100644 Medium/Swap Nodes in Pair.java
 create mode 100644 Medium/Swap Nodes in Pairs.java

diff --git a/Medium/Swap Nodes in Pair.java b/Medium/Swap Nodes in Pair.java
deleted file mode 100644
index 478438f6..00000000
--- a/Medium/Swap Nodes in Pair.java	
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-  public ListNode swapPairs(ListNode head) {
-    if (head == null || head.next == null) {
-      return head;
-    }
-    ListNode next = head.next;
-    head.next = swapPairs(head.next.next);
-    next.next = head;
-    return next;
-  }
-  
-  private ListNode reverseHeadPair(ListNode head) {
-    if (head == null || head.next == null) {
-      return head;
-    }
-    ListNode next = head.next;
-    head.next = reverseHeadPair(head.next.next);
-    next.next = head;
-    return next;
-  }
-}
diff --git a/Medium/Swap Nodes in Pairs.java b/Medium/Swap Nodes in Pairs.java
new file mode 100644
index 00000000..980e4356
--- /dev/null
+++ b/Medium/Swap Nodes in Pairs.java	
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode swapPairs(ListNode head) {
+    ListNode curr = head;
+    ListNode prev = null;
+    while (curr != null && curr.next != null) {
+      ListNode nextNode = curr.next;
+      if (curr == head) {
+        head = nextNode;
+      }
+      curr.next = nextNode.next;
+      nextNode.next = curr;
+      if (prev != null) {
+        prev.next = nextNode;
+      }
+      prev = curr;
+      curr = curr.next;
+    }
+    return head;
+  }
+}

From 8d02cd7145f793847df37b391b58397a3026c0e8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Dec 2020 13:16:27 -0800
Subject: [PATCH 0419/2175] Added Number of Students Unable to Eat Lunch.java

---
 ...umber of Students Unable to Eat Lunch.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Number of Students Unable to Eat Lunch.java

diff --git a/Easy/Number of Students Unable to Eat Lunch.java b/Easy/Number of Students Unable to Eat Lunch.java
new file mode 100644
index 00000000..8a20c5c6
--- /dev/null
+++ b/Easy/Number of Students Unable to Eat Lunch.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int countStudents(int[] students, int[] sandwiches) {
+    int studentIdx = 0;
+    int sandwichIdx = 0;
+    Map<Integer, Integer> studentState = new HashMap<>();
+    while (sandwichIdx < sandwiches.length) {
+      if (sandwiches[sandwichIdx] == students[studentIdx]) {
+        sandwichIdx++;
+        students[studentIdx] = -1;
+      } else if (students[studentIdx] != -1) {
+        // Check to see if we have finished one complete iteration without consuming any sandwich
+        if (studentState.containsKey(studentIdx) && studentState.get(studentIdx) == sandwichIdx) {
+          break;
+        }
+        studentState.put(studentIdx, sandwichIdx);
+      }
+      studentIdx = studentIdx == students.length - 1 ? 0 : studentIdx + 1;
+    }
+    return sandwichIdx == sandwiches.length ? 0 : sandwiches.length - sandwichIdx;
+  }
+}

From 59511d179e320e14849f0f6b62388c4eff9152e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Dec 2020 13:27:50 -0800
Subject: [PATCH 0420/2175] Added Determine if String Halves Are Alike.java

---
 Easy/Determine if String Halves Are Alike.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Determine if String Halves Are Alike.java

diff --git a/Easy/Determine if String Halves Are Alike.java b/Easy/Determine if String Halves Are Alike.java
new file mode 100644
index 00000000..218ce0ed
--- /dev/null
+++ b/Easy/Determine if String Halves Are Alike.java	
@@ -0,0 +1,14 @@
+class Solution {
+  private static final String VOWELS = "aeiouAEIOU";
+  public boolean halvesAreAlike(String s) {
+    return getVowelCount(s.substring(0, s.length() / 2)).equals(getVowelCount(s.substring(s.length() / 2)));
+  }
+  
+  private Long getVowelCount(String s) {
+    return s.chars().mapToObj(c -> (char) c).filter(Solution::isVowel).count();
+  }
+  
+  private static boolean isVowel(char c) {
+    return VOWELS.indexOf(c) != -1;
+  }
+}

From 078b2168991d9cc3dc251097773e3fdc9a6c3e58 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Dec 2020 09:19:51 -0800
Subject: [PATCH 0421/2175] Added Average Waiting Time.java

---
 Medium/Average Waiting Time.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Average Waiting Time.java

diff --git a/Medium/Average Waiting Time.java b/Medium/Average Waiting Time.java
new file mode 100644
index 00000000..66d8f464
--- /dev/null
+++ b/Medium/Average Waiting Time.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public double averageWaitingTime(int[][] customers) {
+    long totalWaitingTime = 0;
+    int currChefTime = 0;
+    for (int[] customer : customers) {
+      currChefTime = Math.max(currChefTime, customer[0]);
+      int endTime = currChefTime + customer[1];
+      totalWaitingTime += endTime - customer[0];
+      currChefTime = endTime;
+    }
+    return totalWaitingTime / (double) customers.length;
+  }
+}

From 3449c171d6b9bfe9a016d77a2541fba88e7f63e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Jan 2021 12:31:50 -0800
Subject: [PATCH 0422/2175] Added Maximum Units on a Truck.java

---
 Easy/Maximum Units on a Truck.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Maximum Units on a Truck.java

diff --git a/Easy/Maximum Units on a Truck.java b/Easy/Maximum Units on a Truck.java
new file mode 100644
index 00000000..da65b654
--- /dev/null
+++ b/Easy/Maximum Units on a Truck.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int maximumUnits(int[][] boxTypes, int truckSize) {
+    PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> {
+      int c = o2[1] - o1[1];
+      if (c != 0) {
+        return c;
+      }
+      return o2[0] - o1[0];
+    });
+    Collections.addAll(pq, boxTypes);
+    int maximumUnits = 0;
+    while (truckSize > 0 && !pq.isEmpty()) {
+      int[] boxType = pq.poll();
+      int boxesAdded = Math.min(boxType[0], truckSize);
+      maximumUnits += boxesAdded * boxType[1];
+      truckSize -= boxesAdded;
+    }
+    return maximumUnits;
+  }
+}

From 7eba27b8b13005137561d62b2684c95eb008fb0d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Jan 2021 09:37:13 -0800
Subject: [PATCH 0423/2175] Update and rename Kth Missing Positive Integer.java
 to Kth Missing Positive Number.java

---
 ...Integer.java => Kth Missing Positive Number.java} | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)
 rename Easy/{Kth Missing Positive Integer.java => Kth Missing Positive Number.java} (61%)

diff --git a/Easy/Kth Missing Positive Integer.java b/Easy/Kth Missing Positive Number.java
similarity index 61%
rename from Easy/Kth Missing Positive Integer.java
rename to Easy/Kth Missing Positive Number.java
index 9721a3c4..b953be98 100644
--- a/Easy/Kth Missing Positive Integer.java	
+++ b/Easy/Kth Missing Positive Number.java	
@@ -1,21 +1,19 @@
 class Solution {
   public int findKthPositive(int[] arr, int k) {
-    int missCount = 0;
     for (int i = 0; i < arr.length; i++) {
-      int curr = arr[i];
+      int curr = arr[i] - 1;
       int prev = i == 0 ? 0 : arr[i - 1];
-      while (prev < (curr - 1)) {
-        missCount++;
+      while (prev < curr) {
+        k--;
         prev++;
-        if (missCount == k) {
+        if (k == 0) {
           return prev;
         }
       }
     }
     int curr = arr[arr.length - 1];
-    while (missCount < k) {
+    while (k-- > 0) {
       curr++;
-      missCount++;
     }
     return curr;
   }

From b0a373e297902fe18777a0ce64e064d1e5c2448e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Jan 2021 06:42:28 -0800
Subject: [PATCH 0424/2175] Refactored Longest Substring Without Repeating
 Characters.java

---
 ...ubstring Without Repeating Characters.java | 33 +++++++++----------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/Medium/Longest Substring Without Repeating Characters.java b/Medium/Longest Substring Without Repeating Characters.java
index 47cd512b..2bef7542 100644
--- a/Medium/Longest Substring Without Repeating Characters.java	
+++ b/Medium/Longest Substring Without Repeating Characters.java	
@@ -1,21 +1,18 @@
 class Solution {
-    public int lengthOfLongestSubstring(String s) {
-        int maxLen = 0;
-        int n = s.length();
-        int start = 0;
-        int end = 0;
-        Set<Character> set = new HashSet<>();
-        
-        while (end < n) {
-            if (!set.contains(s.charAt(end))) {
-                set.add(s.charAt(end++));
-                maxLen = Math.max(maxLen, set.size());
-            }
-            else {
-                set.remove(s.charAt(start++));
-            }
-        }
-        
-        return maxLen;
+  public int lengthOfLongestSubstring(String s) {
+    int start = 0;
+    int end = 0;
+    int n = s.length();
+    Map<Character, Integer> map = new HashMap<>();
+    int maxLength = 0;
+    while (end < n) {
+      char c = s.charAt(end++);
+      map.put(c, map.getOrDefault(c, 0) + 1);
+      while (start <= end && map.get(c) > 1) {
+        map.put(s.charAt(start), map.getOrDefault(s.charAt(start++), 0) - 1);
+      }
+      maxLength = Math.max(maxLength, end - start);
     }
+    return maxLength;
+  }
 }

From fea3167af3d9faf2973c0575d0caf0d3f6009b9a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Jan 2021 18:52:12 -0800
Subject: [PATCH 0425/2175] Refactored Solve the Equation.java

---
 Medium/Solve the Equation.java | 129 +++++++++++----------------------
 1 file changed, 41 insertions(+), 88 deletions(-)

diff --git a/Medium/Solve the Equation.java b/Medium/Solve the Equation.java
index e5edc253..bc506e04 100644
--- a/Medium/Solve the Equation.java	
+++ b/Medium/Solve the Equation.java	
@@ -1,93 +1,46 @@
 class Solution {
-    public String solveEquation(String equation) {
-        int leftXCount = 0;
-        int rightXCount = 0;
-        int leftNumCount = 0;
-        int rightNumCount = 0;
-        boolean switchDone = false;
-        int sign = 1;
-        StringBuilder sb = new StringBuilder();
-
-        for (char c : equation.toCharArray()) {
-            if (c == '=') {
-                if (sb.length() > 0) {
-                    leftNumCount += sign * Integer.parseInt(sb.toString());
-                    sb.setLength(0);
-                    sign = 1;
-                }
-
-                switchDone = true;
-                continue;
-            }
-
-            if (c == 'x') {
-                if (switchDone) {
-                    rightXCount += sign * (sb.length() > 0 ? Integer.parseInt(sb.toString()) : 1);
-                }
-                else {
-                    leftXCount += sign * (sb.length() > 0 ? Integer.parseInt(sb.toString()) : 1);
-                }
-
-                sign = 1;
-                sb.setLength(0);
-            }
-            else if (Character.isDigit(c)) {
-                sb.append(c);
-            }
-            else if (c == '+' || c == '-') {
-                if (sb.length() > 0) {
-                    if (switchDone) {
-                        rightNumCount += sign * (Integer.parseInt(sb.toString()));
-                    }
-                    else {
-                        leftNumCount += sign * (Integer.parseInt(sb.toString()));
-                    }
-
-                    sb.setLength(0);
-                }
-
-                sign = c == '+' ? 1 : -1;
-            }
-        }
-
-        if (sb.length() > 0) {
-            rightNumCount += sign * Integer.parseInt(sb.toString());
-        }
-
-        if (leftXCount == rightXCount && leftNumCount != rightNumCount) {
-            return "No solution";
-        }
-        else if (leftXCount == rightXCount && leftNumCount == rightNumCount) {
-            return "Infinite solutions";
-        }
-        else {
-            int totalXCount = leftXCount - rightXCount;
-            int totalValueCount = rightNumCount - leftNumCount;
-
-            int gcd = getGcd(totalXCount, totalValueCount);
-            if (gcd != 0) {
-                totalXCount /= gcd;
-                totalValueCount /= gcd;
-            }
-
-            if (totalXCount < 0) {
-                totalXCount *= -1;
-                totalValueCount *= -1;
-            }
-
-            return new StringBuilder()
-                            .append(totalXCount > 1 ? totalXCount : "")
-                            .append("x=")
-                            .append(totalValueCount)
-                            .toString();
-        }
+  public String solveEquation(String equation) {
+    int[] equationFirst = parseEquation(equation.split("=")[0]);
+    int[] equationSecond = parseEquation(equation.split("=")[1]);
+    int constantPart = equationSecond[1] - equationFirst[1];
+    int variablePart = equationFirst[0] - equationSecond[0];
+    if (variablePart == 0) {
+      return constantPart == 0 ? "Infinite solutions" : "No solution";
     }
-
-    private int getGcd(int totalXCount, int totalValueCount) {
-        if (totalXCount == 0) {
-            return totalValueCount;
+    int sign = (variablePart < 0 && constantPart < 0) || (variablePart > 0 && constantPart > 0) ? 1 : -1;
+    if (Math.abs(constantPart) % Math.abs(variablePart) == 0) {
+      constantPart = Math.abs(constantPart) / Math.abs(variablePart);
+      variablePart = 1;
+    } 
+    return (variablePart > 1 ? variablePart : "") + "x=" + sign * constantPart;
+  }
+  
+  private int[] parseEquation(String s) {
+    int variablePart = 0;
+    int constantPart = 0;
+    int sign = 1;
+    int n = s.length();
+    for (int idx = 0; idx < n;) {
+      if (s.charAt(idx) == 'x') {
+        variablePart += sign;
+        idx++;
+        sign = 1;
+      } else if (Character.isDigit(s.charAt(idx))) {
+        int num = 0;
+        while (idx < n && Character.isDigit(s.charAt(idx))) {
+          num = num * 10 + Character.getNumericValue(s.charAt(idx++));
+        }
+        if (idx != n && s.charAt(idx) == 'x') {
+          variablePart += sign * num;
+          idx++;
+        } else {
+          constantPart += sign * num;
         }
-
-        return getGcd(totalValueCount % totalXCount, totalXCount);
+        sign = 1;
+      } else {
+        sign = s.charAt(idx++) == '+' ? 1 : -1;
+      }
     }
+    return new int[]{variablePart, constantPart};
+  }
 }

From 7e8f1d641e991ed8f614efa5d943aae76d5e5c15 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Jan 2021 07:01:26 -0800
Subject: [PATCH 0426/2175] Added Calculate Money in Leetcode Bank.java

---
 Easy/Calculate Money in Leetcode Bank.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Calculate Money in Leetcode Bank.java

diff --git a/Easy/Calculate Money in Leetcode Bank.java b/Easy/Calculate Money in Leetcode Bank.java
new file mode 100644
index 00000000..0b4a35dc
--- /dev/null
+++ b/Easy/Calculate Money in Leetcode Bank.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int totalMoney(int n) {
+    int totalAmount = 0;
+    int mondayMoney = 1;
+    while (n > 0) {
+      totalAmount += mondayMoney++;
+      n--;
+      int daysInWeek = Math.min(6, n);
+      totalAmount += getCummulativeSum(mondayMoney, daysInWeek);
+      n -= daysInWeek;
+    }
+    return totalAmount;
+  }
+  
+  private int getCummulativeSum(int firstTerm, int n) {
+    if (n <= 0) {
+      return 0;
+    }
+    return ((2 * firstTerm + (n - 1)) * n) / 2;
+  }
+}

From 0dafdff8f5010ca85da877698f2105c5d174c2b8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Jan 2021 10:40:07 -0800
Subject: [PATCH 0427/2175] Update and rename Merge Sorted Arrays.java to Merge
 Sorted Array.java

---
 Easy/Merge Sorted Array.java  | 22 ++++++++++++++++++++++
 Easy/Merge Sorted Arrays.java | 25 -------------------------
 2 files changed, 22 insertions(+), 25 deletions(-)
 create mode 100644 Easy/Merge Sorted Array.java
 delete mode 100644 Easy/Merge Sorted Arrays.java

diff --git a/Easy/Merge Sorted Array.java b/Easy/Merge Sorted Array.java
new file mode 100644
index 00000000..828d100f
--- /dev/null
+++ b/Easy/Merge Sorted Array.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public void merge(int[] nums1, int m, int[] nums2, int n) {
+    int idx = m + n - 1;
+    int numsOneIdx = m - 1;
+    int numsTwoIdx = n - 1;
+    while (numsOneIdx >= 0 || numsTwoIdx >= 0) {
+      int val = -1;
+      if (numsOneIdx >= 0 && numsTwoIdx >= 0) {
+        if (nums1[numsOneIdx] > nums2[numsTwoIdx]) {
+          val = nums1[numsOneIdx--];
+        } else {
+          val = nums2[numsTwoIdx--];
+        }
+      } else if (numsOneIdx >= 0 && numsTwoIdx < 0) {
+        val = nums1[numsOneIdx--];
+      } else {
+        val = nums2[numsTwoIdx--];
+      }
+      nums1[idx--] = val;
+    }
+  }
+}
diff --git a/Easy/Merge Sorted Arrays.java b/Easy/Merge Sorted Arrays.java
deleted file mode 100644
index d734d76a..00000000
--- a/Easy/Merge Sorted Arrays.java	
+++ /dev/null
@@ -1,25 +0,0 @@
-class Solution {
-  public void merge(int[] nums1, int m, int[] nums2, int n) {
-    int counter = m + n - 1;
-    int num1End = m - 1;
-    int num2End = n - 1;
-    while (num1End >= 0 || num2End >= 0) {
-      int val = -1;
-      if (num1End >= 0 && num2End >= 0) {
-        if (nums1[num1End] > nums2[num2End]) {
-          val = nums1[num1End--];
-        }
-        else {
-          val = nums2[num2End--];
-        }
-      }
-      else if (num1End >= 0 || num2End < 0) {
-        val = nums1[num1End--];
-      }
-      else {
-        val = nums2[num2End--];
-      }
-      nums1[counter--] = val;
-    }
-  }
-}

From 01a6c84f1cf3734adf7c8f6bc74738d377eaa009 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Jan 2021 07:25:00 -0800
Subject: [PATCH 0428/2175] Added Minimum Operations to Reduce X to Zero.java

---
 ...inimum Operations to Reduce X to Zero.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Minimum Operations to Reduce X to Zero.java

diff --git a/Medium/Minimum Operations to Reduce X to Zero.java b/Medium/Minimum Operations to Reduce X to Zero.java
new file mode 100644
index 00000000..ebd3de44
--- /dev/null
+++ b/Medium/Minimum Operations to Reduce X to Zero.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public int minOperations(int[] nums, int x) {
+    int n = nums.length;
+    int leftIdx = 0;
+    int sum = 0;
+    int ans = -1;
+    for (; leftIdx < n && sum < x; leftIdx++) {
+      sum += nums[leftIdx];
+    }
+    if (sum == x) {
+      ans = leftIdx;
+    }
+    leftIdx--;
+    int rightIdx = n - 1;
+    for (; leftIdx >= 0; leftIdx--) {
+      sum -= nums[leftIdx];
+      while (rightIdx > leftIdx && sum < x) {
+        sum += nums[rightIdx--];
+      }
+      if (sum == x) {
+        ans = ans == -1 ? (leftIdx + n - rightIdx - 1) : Math.min(ans, (leftIdx + n - rightIdx - 1));
+      }
+    }
+    return ans;
+  }
+}

From e8a5305eaa4b5e8265e7bbbd2a5ff16439b502ff Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 15 Jan 2021 18:48:20 -0800
Subject: [PATCH 0429/2175] Added Decode XORed Array.java

---
 Easy/Decode XORed Array.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Decode XORed Array.java

diff --git a/Easy/Decode XORed Array.java b/Easy/Decode XORed Array.java
new file mode 100644
index 00000000..fa9442a4
--- /dev/null
+++ b/Easy/Decode XORed Array.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public int[] decode(int[] encoded, int first) {
+    int[] ans = new int[encoded.length + 1];
+    ans[0] = first;
+    for (int i = 0; i < encoded.length; i++) {
+      ans[i + 1] = ans[i] ^ encoded[i];
+    }
+    return ans;
+  }
+}

From 843149633cc8b18c3c6b2abffe196603ec601fd4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Jan 2021 06:53:26 -0800
Subject: [PATCH 0430/2175] Refactored Kth Largest Element in an Array.java

---
 Medium/Kth Largest Element in an Array.java | 22 +++++++--------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/Medium/Kth Largest Element in an Array.java b/Medium/Kth Largest Element in an Array.java
index 8c2a6d59..eab17f53 100644
--- a/Medium/Kth Largest Element in an Array.java	
+++ b/Medium/Kth Largest Element in an Array.java	
@@ -1,18 +1,10 @@
 class Solution {
-    public static int findKthLargest(int[] nums, int k) {
-        PriorityQueue<Integer> queue = new PriorityQueue<>(k);
-        for (int i=0; i<nums.length; i++) {
-            if (queue.size() < k) {
-                queue.add(nums[i]);
-            }
-            else {
-                if (nums[i] > queue.peek()) {
-                    queue.remove();
-                    queue.add(nums[i]);
-                }
-            }
-        }
-
-        return queue.remove();
+  public int findKthLargest(int[] nums, int k) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> o2 - o1);
+    pq.addAll(Arrays.stream(nums).boxed().collect(Collectors.toList()));
+    while (k-- > 1) {
+      pq.poll();
     }
+    return pq.poll();
+  }
 }

From d5a43967d8e8072041b3d84063a956fd20b2104d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Jan 2021 21:41:09 -0800
Subject: [PATCH 0431/2175] Added Number Of Rectangles That Can Form The
 Largest Square.java

---
 ... Rectangles That Can Form The Largest Square.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Number Of Rectangles That Can Form The Largest Square.java

diff --git a/Number Of Rectangles That Can Form The Largest Square.java b/Number Of Rectangles That Can Form The Largest Square.java
new file mode 100644
index 00000000..3368c00f
--- /dev/null
+++ b/Number Of Rectangles That Can Form The Largest Square.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int countGoodRectangles(int[][] rectangles) {
+    int maxSquareSide = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int[] rectangle : rectangles) {
+      int currSquareSide = Math.min(rectangle[0], rectangle[1]);
+      map.put(currSquareSide, map.getOrDefault(currSquareSide, 0) + 1);
+      maxSquareSide = Math.max(maxSquareSide, currSquareSide);
+    }
+    return map.get(maxSquareSide);
+  }
+}

From bcd4e8e6c1900b5621de1cc3e1e5e2b4eb062f19 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Jan 2021 07:30:27 -0800
Subject: [PATCH 0432/2175] Added Tuple With Same Product.java

---
 Medium/Tuple With Same Product.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Tuple With Same Product.java

diff --git a/Medium/Tuple With Same Product.java b/Medium/Tuple With Same Product.java
new file mode 100644
index 00000000..fa9165e6
--- /dev/null
+++ b/Medium/Tuple With Same Product.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int tupleSameProduct(int[] nums) {
+    int count = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+      for (int j = i + 1; j < nums.length; j++) {
+        int prod = nums[i] * nums[j];
+        count += map.getOrDefault(prod, 0);
+        map.put(prod, map.getOrDefault(prod, 0) + 1);
+      }
+    }
+    return count * 8;
+  }
+}

From 27116889ac47f36c6888bca2d60034c2bbb4ba2b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Jan 2021 20:26:47 -0800
Subject: [PATCH 0433/2175] Added Smallest Range I.java

---
 Easy/Smallest Range I.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Smallest Range I.java

diff --git a/Easy/Smallest Range I.java b/Easy/Smallest Range I.java
new file mode 100644
index 00000000..8ba8f821
--- /dev/null
+++ b/Easy/Smallest Range I.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int smallestRangeI(int[] A, int K) {
+    int maximum = A[0];
+    int minimum = A[0];
+    for (int num : A) {
+      maximum = Math.max(num, maximum);
+      minimum = Math.min(num, minimum);
+    }
+    return Math.max(0, maximum - minimum - 2 * K); 
+  }
+}

From 905a5062773b124934e435344ea6612264220ce1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 18 Jan 2021 10:17:02 -0800
Subject: [PATCH 0434/2175] Refactored Max Number of K-Sum Pairs.java

---
 Medium/Max Number of K-Sum Pairs.java | 23 ++++++++---------------
 1 file changed, 8 insertions(+), 15 deletions(-)

diff --git a/Medium/Max Number of K-Sum Pairs.java b/Medium/Max Number of K-Sum Pairs.java
index 1669f456..fa942c0e 100644
--- a/Medium/Max Number of K-Sum Pairs.java	
+++ b/Medium/Max Number of K-Sum Pairs.java	
@@ -1,22 +1,15 @@
 class Solution {
   public int maxOperations(int[] nums, int k) {
-    Map<Integer, Integer> counter = new HashMap<>();
+    Map<Integer, Integer> map = new HashMap<>();
+    int count = 0;
     for (int num : nums) {
-      counter.put(num, counter.getOrDefault(num, 0) + 1);
-    }
-    Set<Integer> keys = counter.keySet();
-    int numOfPairs = 0;
-    for (Integer key : keys) {
-      if (counter.containsKey(k - key) && (k - key != key)) {
-        int min = Math.min(counter.get(key), counter.get(k - key));
-        counter.put(key, counter.get(key) - min);
-        counter.put(k - key, counter.get(k - key) - min);
-        numOfPairs += min;
-      } else if (counter.containsKey(k - key) && (k - key == key)) {
-        numOfPairs += counter.get(key) / 2;
-        counter.put(key, counter.get(key) / 2);
+      if (map.getOrDefault(k - num, 0) > 0) {
+        count++;
+        map.put(k - num, map.getOrDefault(k - num, 0) - 1);
+      } else {
+        map.put(num, map.getOrDefault(num, 0) + 1);
       }
     }
-    return numOfPairs;
+    return count;
   }
 }

From 7f5b7e5a75762c8e21e2c446b7b74ac83b8892d9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 18 Jan 2021 10:21:50 -0800
Subject: [PATCH 0435/2175] Rename Number Of Rectangles That Can Form The
 Largest Square.java to Easy/Number Of Rectangles That Can Form The Largest
 Square.java

---
 .../Number Of Rectangles That Can Form The Largest Square.java    | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename Number Of Rectangles That Can Form The Largest Square.java => Easy/Number Of Rectangles That Can Form The Largest Square.java (100%)

diff --git a/Number Of Rectangles That Can Form The Largest Square.java b/Easy/Number Of Rectangles That Can Form The Largest Square.java
similarity index 100%
rename from Number Of Rectangles That Can Form The Largest Square.java
rename to Easy/Number Of Rectangles That Can Form The Largest Square.java

From 3e7337bcc2a4743cec556b51405165a15f80f285 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 19 Jan 2021 20:52:02 -0800
Subject: [PATCH 0436/2175] Added Swapping Nodes in a Linked List.java

---
 Medium/Swapping Nodes in a Linked List.java | 31 +++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Swapping Nodes in a Linked List.java

diff --git a/Medium/Swapping Nodes in a Linked List.java b/Medium/Swapping Nodes in a Linked List.java
new file mode 100644
index 00000000..e16f50b1
--- /dev/null
+++ b/Medium/Swapping Nodes in a Linked List.java	
@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode swapNodes(ListNode head, int k) {
+    ListNode fast = null;
+    ListNode curr = head;
+    int currCount = 1;
+    while (currCount != k) {
+      curr = curr.next;
+      currCount++;
+    }
+    fast = curr;
+    ListNode slow = head;
+    while (curr.next != null) {
+      slow = slow.next;
+      curr = curr.next;
+    }
+    int temp = fast.val;
+    fast.val = slow.val;
+    slow.val = temp;
+    return head;
+  }
+}

From 5e55437a8d457ad3bf56aab1755a3f6e14f2e2b4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Jan 2021 07:12:34 -0800
Subject: [PATCH 0437/2175] Update and rename Valid Parantheses.java to Valid
 Parentheses.java

---
 Easy/Valid Parantheses.java | 26 --------------------------
 Easy/Valid Parentheses.java | 17 +++++++++++++++++
 2 files changed, 17 insertions(+), 26 deletions(-)
 delete mode 100644 Easy/Valid Parantheses.java
 create mode 100644 Easy/Valid Parentheses.java

diff --git a/Easy/Valid Parantheses.java b/Easy/Valid Parantheses.java
deleted file mode 100644
index 4f6d95b3..00000000
--- a/Easy/Valid Parantheses.java	
+++ /dev/null
@@ -1,26 +0,0 @@
-class Solution {
-  public boolean isValid(String s) {
-    Stack<Character> stack = new Stack<>();
-    String closing = ")}]";
-    String opening = "({[";
-    
-    for (char c : s.toCharArray()) {
-      if (closing.indexOf(c) == -1) {
-        stack.push(c);
-      }
-      else {
-        if (stack.isEmpty()) {
-          System.out.println("HERE");
-          return false;
-        }
-        char temp = stack.pop();
-        if (opening.indexOf(temp) != closing.indexOf(c)) {
-          System.out.println(opening.indexOf(temp) + " " + closing.indexOf(c));
-          return false;
-        }
-      }
-    }
-    System.out.println(stack);
-    return stack.isEmpty();
-  }
-}
diff --git a/Easy/Valid Parentheses.java b/Easy/Valid Parentheses.java
new file mode 100644
index 00000000..3e93ca6e
--- /dev/null
+++ b/Easy/Valid Parentheses.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean isValid(String s) {
+    String starting = "({[";
+    String ending = ")}]";
+    Stack<Character> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
+      if (starting.indexOf(c) != -1) {
+        stack.push(c);
+      } else {
+        if (stack.isEmpty() || starting.indexOf(stack.pop()) != ending.indexOf(c)) {
+          return false;
+        }
+      }
+    }
+    return stack.isEmpty();
+  }
+}

From e312d85f6b2cedfa16339cb3fdc0691ab135981f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Jan 2021 15:11:21 -0800
Subject: [PATCH 0438/2175] Added Determine if Two Strings Are Close.java

---
 .../Determine if Two Strings Are Close.java   | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Medium/Determine if Two Strings Are Close.java

diff --git a/Medium/Determine if Two Strings Are Close.java b/Medium/Determine if Two Strings Are Close.java
new file mode 100644
index 00000000..96a5181a
--- /dev/null
+++ b/Medium/Determine if Two Strings Are Close.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public boolean closeStrings(String word1, String word2) {
+    if (word1.length() != word2.length()) {
+      return false;
+    }
+    int[] frequencyOne = getFrequencyArray(word1);
+    int[] frequencyTwo = getFrequencyArray(word2);
+    for (int i = 0; i < frequencyOne.length; i++) {
+      if (frequencyOne[i] == 0 && frequencyTwo[i] != 0) {
+        return false;
+      }
+    }
+    Arrays.sort(frequencyOne);
+    Arrays.sort(frequencyTwo);
+    for (int i = 0; i < frequencyOne.length; i++) {
+      if (frequencyOne[i] != frequencyTwo[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  private int[] getFrequencyArray(String s) {
+    int[] frequency = new int[26];
+    for (char c : s.toCharArray()) {
+      frequency[c - 'a']++;
+    }
+    return frequency;
+  }
+}

From 577bc69c520c56fbbca89356e79f878589c01437 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Jan 2021 08:04:32 -0800
Subject: [PATCH 0439/2175] Added Find the Highest Altitude.java

---
 Easy/Find the Highest Altitude.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Find the Highest Altitude.java

diff --git a/Easy/Find the Highest Altitude.java b/Easy/Find the Highest Altitude.java
new file mode 100644
index 00000000..a7df7bf1
--- /dev/null
+++ b/Easy/Find the Highest Altitude.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int largestAltitude(int[] gain) {
+    int highestAltitude = 0;
+    int currAltitude = 0;
+    for (int i = 0; i < gain.length; i++) {
+      currAltitude += gain[i];
+      highestAltitude = Math.max(highestAltitude, currAltitude);
+    }
+    return highestAltitude;
+  }
+}

From 691f418834ebbfbf2b74cbab32bf3934de32fd29 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Jan 2021 21:32:00 -0800
Subject: [PATCH 0440/2175] Added Latest Time by Replacing Hidden Digits.java

---
 ...atest Time by Replacing Hidden Digits.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Easy/Latest Time by Replacing Hidden Digits.java

diff --git a/Easy/Latest Time by Replacing Hidden Digits.java b/Easy/Latest Time by Replacing Hidden Digits.java
new file mode 100644
index 00000000..2bb4a840
--- /dev/null
+++ b/Easy/Latest Time by Replacing Hidden Digits.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public String maximumTime(String time) {
+    char[] digits = time.toCharArray();
+    if (digits[0] == '?' || digits[1] == '?') {
+      if (digits[0] == '?') {
+        if (digits[1] == '?' || Character.getNumericValue(digits[1]) <= 3) {
+          digits[0] = '2';
+        } else {
+          digits[0] = '1';
+        }
+      }
+      if (digits[1] == '?') {
+        if (Character.getNumericValue(digits[0]) <= 1) {
+          digits[1] = '9';
+        } else {
+          digits[1] = '3';
+        }
+      }
+    }
+    if (digits[3] == '?' || digits[4] == '?') {
+      if (digits[3] == '?') {
+        digits[3] = '5';
+      }
+      if (digits[4] == '?') {
+        digits[4] = '9';
+      }
+    }
+    return String.valueOf(digits);
+  }
+}

From 17ed31f3d208c7bc92e9992684e80802de73423e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 24 Jan 2021 07:02:56 -0800
Subject: [PATCH 0441/2175] Refactored Merge K Sorted Lists.java

---
 Hard/Merge K Sorted Lists.java | 54 +++++++++++++---------------------
 1 file changed, 21 insertions(+), 33 deletions(-)

diff --git a/Hard/Merge K Sorted Lists.java b/Hard/Merge K Sorted Lists.java
index 7f225ffc..df8ddc91 100644
--- a/Hard/Merge K Sorted Lists.java	
+++ b/Hard/Merge K Sorted Lists.java	
@@ -3,41 +3,29 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode mergeKLists(ListNode[] lists) {
-        if (lists.length == 0) {
-            return null;
-        }
-
-        PriorityQueue<ListNode> queue = new PriorityQueue<>(lists.length, new Comparator<ListNode>() {
-            @Override
-            public int compare(ListNode o1, ListNode o2) {
-                return o1.val - o2.val;
-            }
-        });
-
-        for (int i = 0; i < lists.length; i++) {
-            if (lists[i] != null) {
-                queue.add(lists[i]);
-            }
-        }
-
-        ListNode head = new ListNode(0);
-        ListNode p = head;
-
-        while (!queue.isEmpty()) {
-            ListNode node = queue.poll();
-            p.next = node;
-            if (node.next != null) {
-                queue.add(node.next);
-            }
-
-            p = p.next;
-        }
-
-        return head.next;
+  public ListNode mergeKLists(ListNode[] lists) {
+    PriorityQueue<ListNode> pq = new PriorityQueue<>((a, b) -> a.val - b.val);
+    for (ListNode listNode : lists) {
+      if (listNode != null) {
+        pq.add(listNode);
+      }
     }
+    ListNode dummy = new ListNode(0);
+    ListNode curr = dummy;
+    while (!pq.isEmpty()) {
+      ListNode removed = pq.remove();
+      curr.next = new ListNode(removed.val);
+      curr = curr.next;
+      if (removed.next != null) {
+        pq.add(removed.next);
+      }
+    }
+    return dummy.next;
+  }
 }

From f2770aae404337580e7a4aef81ee3cd1c87a649c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Jan 2021 06:42:15 -0800
Subject: [PATCH 0442/2175] Added Path With Minimum Effort.java

---
 Medium/Path With Minimum Effort.java | 38 ++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Medium/Path With Minimum Effort.java

diff --git a/Medium/Path With Minimum Effort.java b/Medium/Path With Minimum Effort.java
new file mode 100644
index 00000000..5d336e11
--- /dev/null
+++ b/Medium/Path With Minimum Effort.java	
@@ -0,0 +1,38 @@
+class Solution {
+  public int minimumEffortPath(int[][] heights) {
+    int rows = heights.length;
+    int cols = heights[0].length;
+    int[][] directions = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+    int[][] distance = new int[rows][cols];
+    for (int i = 0; i < rows; i++) {
+      Arrays.fill(distance[i], Integer.MAX_VALUE);
+    }
+    PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
+    pq.add(new int[]{0, 0, 0});
+    while (!pq.isEmpty()) {
+      int[] removed = pq.poll();
+      int currDistance = removed[0];
+      int x = removed[1];
+      int y = removed[2];
+      if (currDistance > distance[x][y]) {
+        continue;
+      }
+      if (x == rows - 1 && y == cols - 1) {
+        return currDistance;
+      }
+      for (int[] direction : directions) {
+        int newX = x + direction[0];
+        int newY = y + direction[1];
+        if (newX < 0 || newX >= rows || newY < 0 || newY >= cols) {
+          continue;
+        }
+        int newDistance = Math.max(currDistance, Math.abs(heights[newX][newY] - heights[x][y]));
+        if (distance[newX][newY] > newDistance) {
+          distance[newX][newY] = newDistance;
+          pq.add(new int[]{newDistance, newX, newY});
+        }
+      }
+    }
+    return -1;
+  }
+}

From 5b77b9308b05b20b155e8e223c506bb226d25023 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Jan 2021 06:17:24 -0800
Subject: [PATCH 0443/2175] Refactored Vertical Order Traversal Of Binary
 Tree.java

---
 ...rtical Order Traversal Of Binary Tree.java | 72 ++++++++++---------
 1 file changed, 38 insertions(+), 34 deletions(-)

diff --git a/Medium/Vertical Order Traversal Of Binary Tree.java b/Medium/Vertical Order Traversal Of Binary Tree.java
index 0459a5f6..ec9e234f 100644
--- a/Medium/Vertical Order Traversal Of Binary Tree.java	
+++ b/Medium/Vertical Order Traversal Of Binary Tree.java	
@@ -4,60 +4,64 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public List<List<Integer>> verticalTraversal(TreeNode root) {
-    if (root == null) {
-      return new ArrayList<>();
-    }
-    Map<Integer, List<TreeLevel>> map = new TreeMap<>();
-    Queue<TreeLevel> queue = new LinkedList<>();
-    queue.add(new TreeLevel(root, 0, 0));
+    Comparator<NodePoint> nodePointComparator = (o1, o2) -> {
+      int c = o2.y - o1.y;
+      if (c != 0) {
+        return c;
+      }
+      return o1.node.val - o2.node.val;
+    };
+    Map<Integer, PriorityQueue<NodePoint>> map = new TreeMap<>();
+    Queue<NodePoint> queue = new LinkedList<>();
+    queue.add(new NodePoint(0, 0, root));
     while (!queue.isEmpty()) {
       int size = queue.size();
       while (size-- > 0) {
-        TreeLevel removed = queue.remove();
-        map.computeIfAbsent(removed.xLevel, k -> new ArrayList<>()).add(removed);
+        NodePoint removed = queue.remove();
+        map.computeIfAbsent(
+            removed.x, k -> new PriorityQueue<>(nodePointComparator))
+            .add(removed);
         if (removed.node.left != null) {
-          queue.add(new TreeLevel(removed.node.left, removed.xLevel - 1, removed.yLevel - 1));
+          queue.add(new NodePoint(removed.x - 1, removed.y - 1, removed.node.left));
         }
         if (removed.node.right != null) {
-          queue.add(new TreeLevel(removed.node.right, removed.xLevel + 1, removed.yLevel - 1));
+          queue.add(new NodePoint(removed.x + 1, removed.y - 1, removed.node.right));
         }
       }
     }
-    List<List<Integer>> list = new ArrayList<>();
+    List<List<Integer>> result = new ArrayList<>();
     for (Integer key : map.keySet()) {
-      List<TreeLevel> temp = map.get(key);
-      Collections.sort(temp, new Comparator<TreeLevel>(){
-        public int compare(TreeLevel t1, TreeLevel t2) {
-          int c = t2.yLevel - t1.yLevel;
-          if (c == 0) {
-            c = t1.node.val - t2.node.val;
-          }
-          return c;
-        }
-      });
-      List<Integer> valTemp = new ArrayList<>();
-      for (TreeLevel t : temp) {
-        valTemp.add(t.node.val);
+      PriorityQueue<NodePoint> pq = map.get(key);
+      List<Integer> temp = new ArrayList<>();
+      while (!pq.isEmpty()) {
+        temp.add(pq.poll().node.val);
       }
-      list.add(valTemp);
+      result.add(temp);
     }
-    return list;
+    return result;
   }
 }
 
-class TreeLevel {
+
+class NodePoint {
+  int x;
+  int y;
   TreeNode node;
-  int xLevel;
-  int yLevel;
-  
-  public TreeLevel(TreeNode node, int xLevel, int yLevel) {
+
+  public NodePoint(int x, int y, TreeNode node) {
+    this.x = x;
+    this.y = y;
     this.node = node;
-    this.xLevel = xLevel;
-    this.yLevel = yLevel;
   }
 }

From bde0955972040d54888a515810c0b62f0691418d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Jan 2021 11:34:25 -0800
Subject: [PATCH 0444/2175] Added Minimize Deviation in Array.java

---
 Hard/Minimize Deviation in Array.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Hard/Minimize Deviation in Array.java

diff --git a/Hard/Minimize Deviation in Array.java b/Hard/Minimize Deviation in Array.java
new file mode 100644
index 00000000..cc449c6c
--- /dev/null
+++ b/Hard/Minimize Deviation in Array.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int minimumDeviation(int[] nums) {
+    int minimumValue = Integer.MAX_VALUE;
+    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b.compareTo(a));
+    for (int num : nums) {
+      if (num % 2 != 0) {
+        num *= 2;
+      }
+      minimumValue = Math.min(minimumValue, num);
+      pq.add(num);
+    }
+    int result = Integer.MAX_VALUE;
+    while (pq.peek() % 2 == 0) {
+      int removed = pq.poll() / 2;
+      minimumValue = Math.min(minimumValue, removed);
+      pq.add(removed);
+      result = Math.min(result, pq.peek() - minimumValue);
+    }
+    return result;
+  }
+}

From 68d1e1e06df3a77a663c6626a6b985a63f2860b2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Jan 2021 21:02:40 -0800
Subject: [PATCH 0445/2175] Added Maximum Number of Balls in a Box.java

---
 Easy/Maximum Number of Balls in a Box.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Maximum Number of Balls in a Box.java

diff --git a/Easy/Maximum Number of Balls in a Box.java b/Easy/Maximum Number of Balls in a Box.java
new file mode 100644
index 00000000..1cde1b06
--- /dev/null
+++ b/Easy/Maximum Number of Balls in a Box.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int countBalls(int lowLimit, int highLimit) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int maxCount = 0;
+    for (int num = lowLimit; num <= highLimit; num++) {
+      int digitSum = getDigitSum(num);
+      map.put(digitSum, map.getOrDefault(digitSum, 0) + 1);
+      maxCount = Math.max(maxCount, map.get(digitSum));
+    }
+    return maxCount;
+  }
+  
+  private int getDigitSum(int num) {
+    int sum = 0;
+    while (num > 0) {
+      sum += num % 10;
+      num /= 10;
+    }
+    return sum;
+  }
+}

From 3a24b47beb42b5524f9f382e5760592e127529fc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Jan 2021 12:45:10 -0800
Subject: [PATCH 0446/2175] Added Restore the Array From Adjacent Pairs.java

---
 ...Restore the Array From Adjacent Pairs.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Restore the Array From Adjacent Pairs.java

diff --git a/Medium/Restore the Array From Adjacent Pairs.java b/Medium/Restore the Array From Adjacent Pairs.java
new file mode 100644
index 00000000..bbe2461c
--- /dev/null
+++ b/Medium/Restore the Array From Adjacent Pairs.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int[] restoreArray(int[][] adjacentPairs) {
+    Map<Integer, List<Integer>> map = new HashMap<>();
+    for (int[] pair : adjacentPairs) {
+      map.computeIfAbsent(pair[0], k -> new ArrayList<>()).add(pair[1]);
+      map.computeIfAbsent(pair[1], k -> new ArrayList<>()).add(pair[0]);
+    }
+    int head = map.keySet().stream().filter(k -> map.get(k).size() == 1).findFirst().orElse(-1);
+    Set<Integer> visited = new HashSet<>();
+    int[] result = new int[map.size()];
+    int idx = 0;
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(head);
+    while (!queue.isEmpty()) {
+      int removed = queue.remove();
+      if (visited.contains(removed)) {
+        continue;
+      }
+      result[idx++] = removed;
+      visited.add(removed);
+      queue.addAll(map.get(removed));
+    }
+    return result;
+  }
+}

From c1c792dcfed2ddfa9c8e69e757b55d3621bc1292 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 2 Feb 2021 08:38:43 -0800
Subject: [PATCH 0447/2175] Refactored Trim a Binary Search Tree.java

---
 Easy/Trim a Binary Search Tree.java   | 27 ------------------------
 Medium/Trim a Binary Search Tree.java | 30 +++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 27 deletions(-)
 delete mode 100644 Easy/Trim a Binary Search Tree.java
 create mode 100644 Medium/Trim a Binary Search Tree.java

diff --git a/Easy/Trim a Binary Search Tree.java b/Easy/Trim a Binary Search Tree.java
deleted file mode 100644
index b596e6b2..00000000
--- a/Easy/Trim a Binary Search Tree.java	
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-  public TreeNode trimBST(TreeNode root, int L, int R) {
-    if (root == null) {
-      return null;
-    }
-    if (root.val < L) {
-      return trimBST(root.right, L, R);
-    }
-    else if (root.val > R) {
-      return trimBST(root.left, L, R);
-    }
-    else {
-      root.left = trimBST(root.left, L, R);
-      root.right = trimBST(root.right, L, R);
-      return root;
-    }
-  }
-}
diff --git a/Medium/Trim a Binary Search Tree.java b/Medium/Trim a Binary Search Tree.java
new file mode 100644
index 00000000..d7b8d9ff
--- /dev/null
+++ b/Medium/Trim a Binary Search Tree.java	
@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode trimBST(TreeNode root, int low, int high) {
+    if (root == null) {
+      return null;
+    }
+    if (root.val < low) {
+      return trimBST(root.right, low, high);
+    } else if (root.val > high) {
+      return trimBST(root.left, low, high);
+    }
+    root.left = trimBST(root.left, low, high);
+    root.right = trimBST(root.right, low, high);
+    return root;
+  }
+}

From a84ac185f47b549539302710321425f43639d151 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Feb 2021 10:25:21 -0800
Subject: [PATCH 0448/2175] Refactored Longest Harmonious Subsequence.java

---
 Easy/Longest Harmonious Subsequence.java | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/Easy/Longest Harmonious Subsequence.java b/Easy/Longest Harmonious Subsequence.java
index cd052aa8..97d0ec4a 100644
--- a/Easy/Longest Harmonious Subsequence.java	
+++ b/Easy/Longest Harmonious Subsequence.java	
@@ -1,15 +1,13 @@
 class Solution {
   public int findLHS(int[] nums) {
-    Map<Integer, Integer> map = new HashMap<>();
-    for (int num : nums) {
-      map.put(num, map.getOrDefault(num, 0) + 1);
-    }
-    int res = 0;
+    Map<Integer, Long> map = Arrays.stream(nums).boxed()
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
+    int result = 0;
     for (Integer key : map.keySet()) {
       if (map.containsKey(key + 1)) {
-        res = Math.max(res, map.get(key) + map.get(key + 1));
+        result = Math.max(result, (int) (map.get(key) + map.get(key + 1)));
       }
     }
-    return res;
+    return result;
   }
 }

From 79c75cd342af6c1091525a7ce4c31f0067709b7f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 5 Feb 2021 05:40:40 -0800
Subject: [PATCH 0449/2175] Refactored Simplify Path.java

---
 Medium/Simplify Path.java | 37 ++++++++++++-------------------------
 1 file changed, 12 insertions(+), 25 deletions(-)

diff --git a/Medium/Simplify Path.java b/Medium/Simplify Path.java
index b272d133..51c19971 100644
--- a/Medium/Simplify Path.java	
+++ b/Medium/Simplify Path.java	
@@ -1,35 +1,22 @@
 class Solution {
   public String simplifyPath(String path) {
     Stack<String> stack = new Stack<>();
-    StringBuilder sb = new StringBuilder();
-    int idx = 0;
-    int n = path.length();
-    while (idx < n) {
-      if (path.charAt(idx) == '/') {
-        idx++;
-        while (idx < n && path.charAt(idx) != '/') {
-          sb.append(path.charAt(idx++));
-        }
-        String dir = sb.toString();
-        sb.setLength(0);
-        if (dir.equals("..")) {
-          if (!stack.isEmpty()) {
-            stack.pop(); 
-          }
-        }
-        else if (dir.equals(".") || dir.length() == 0) {
-          continue;
-        }
-        else {
-          stack.push(dir);
+    String[] splits = path.split("/");
+    for (String split : splits) {
+      if (split.equals("") || split.equals(".")) {
+        continue;
+      } else if (split.equals("..")) {
+        if (!stack.isEmpty()) {
+          stack.pop();
         }
+      } else {
+        stack.push(split);
       }
     }
-    sb = new StringBuilder();
+    StringBuilder resultingPath = new StringBuilder();
     while (!stack.isEmpty()) {
-      sb.insert(0, stack.pop());
-      sb.insert(0, "/");
+      resultingPath.insert(0, stack.pop()).insert(0, "/");
     }
-    return sb.length() > 0 ? sb.toString() : "/";
+    return resultingPath.length() == 0 ? "/" : resultingPath.toString();
   }
 }

From 4cc2a75e6ee029288ba6b777db3eec5c3e9533ff Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 6 Feb 2021 09:56:21 -0800
Subject: [PATCH 0450/2175] Refactored Binary Tree Right Side View.java

---
 Medium/Binary Tree Right Side View.java | 61 ++++++++++++-------------
 1 file changed, 30 insertions(+), 31 deletions(-)

diff --git a/Medium/Binary Tree Right Side View.java b/Medium/Binary Tree Right Side View.java
index 47330c6f..b75c8784 100644
--- a/Medium/Binary Tree Right Side View.java	
+++ b/Medium/Binary Tree Right Side View.java	
@@ -4,41 +4,40 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    List<Integer> list;
-    public List<Integer> rightSideView(TreeNode root) {
-        list = new ArrayList<>();
-        if (root == null) {
-            return list;
-        }
-        
-        helper(root);
-        return list;
+  public List<Integer> rightSideView(TreeNode root) {
+    if (root == null) {
+      return new ArrayList<>();
     }
-    
-    private void helper(TreeNode root) {
-        Queue<TreeNode> queue = new LinkedList<>();
-        queue.add(root);
-        
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            
-            for (int i=1; i<=size; i++) {
-                TreeNode popped = queue.remove();
-                if (popped.left != null) {
-                    queue.add(popped.left);
-                }
-                if (popped.right != null) {
-                    queue.add(popped.right);
-                }
-                
-                if (i == size) {
-                    list.add(popped.val);
-                }
-            }
+    List<Integer> list = new ArrayList<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      TreeNode rightMost = null;
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        if (rightMost == null) {
+          rightMost = removed;
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
         }
+        if (removed.left != null) {
+          queue.add(removed.left);
+        } 
+      }
+      list.add(rightMost.val);
     }
+    return list;
+  }
 }

From 8c8dba7fbd21bb1191ad7fc562fd956a84cd89c0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 6 Feb 2021 11:24:54 -0800
Subject: [PATCH 0451/2175] Added Sum of Unique Elements.java

---
 Easy/Sum of Unique Elements.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Sum of Unique Elements.java

diff --git a/Easy/Sum of Unique Elements.java b/Easy/Sum of Unique Elements.java
new file mode 100644
index 00000000..50782e0c
--- /dev/null
+++ b/Easy/Sum of Unique Elements.java	
@@ -0,0 +1,10 @@
+import java.util.Map.Entry;
+
+class Solution {
+  public int sumOfUnique(int[] nums) {
+    return Arrays.stream(nums).boxed()
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()))
+        .entrySet().stream().filter(e -> e.getValue().equals(1L)).map(
+            Entry::getKey).reduce(0, Integer::sum);
+  }
+}

From 6b9256da5cabe9b0f8f6de1b31ce0e9107d467bd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 6 Feb 2021 17:17:34 -0800
Subject: [PATCH 0452/2175] Added Maximum Absolute Sum of Any Subarray.java

---
 Medium/Maximum Absolute Sum of Any Subarray.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Maximum Absolute Sum of Any Subarray.java

diff --git a/Medium/Maximum Absolute Sum of Any Subarray.java b/Medium/Maximum Absolute Sum of Any Subarray.java
new file mode 100644
index 00000000..0dbca0d6
--- /dev/null
+++ b/Medium/Maximum Absolute Sum of Any Subarray.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int maxAbsoluteSum(int[] nums) {
+    int currMax = nums[0]; 
+    int max = currMax; 
+    int currMin = nums[0];
+    int min = currMin;
+    for(int i = 1; i < nums.length; i++){
+        currMax = Math.max(nums[i], currMax + nums[i]);
+        max = Math.max(max, currMax);
+        currMin = Math.min(nums[i], currMin + nums[i]);
+        min = Math.min(min, currMin);
+    }
+    return Math.max(max, Math.abs(min));
+  }
+}

From 991786f92de75ef61259ef836b175db8b7aa2e8f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Feb 2021 10:23:41 -0800
Subject: [PATCH 0453/2175] Added Check if Array Is Sorted and Rotated.java

---
 Easy/Check if Array Is Sorted and Rotated.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Check if Array Is Sorted and Rotated.java

diff --git a/Easy/Check if Array Is Sorted and Rotated.java b/Easy/Check if Array Is Sorted and Rotated.java
new file mode 100644
index 00000000..4016c5b1
--- /dev/null
+++ b/Easy/Check if Array Is Sorted and Rotated.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean check(int[] nums) {
+    boolean rotationFound = false;
+    for (int i = 0; i < nums.length - 1; i++) {
+      if (nums[i] > nums[i + 1]) {
+        if (rotationFound) {
+          return false;
+        }
+        rotationFound = true;
+      }
+    }
+    if (rotationFound && nums[nums.length - 1] > nums[0]) {
+      return false;
+    }
+    return true;
+  }
+}

From b64b386b6ff464a6129b72b6f0865f8237d260b9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Feb 2021 05:49:40 -0800
Subject: [PATCH 0454/2175] Refactored Peeking Iterator.java

---
 Medium/Peeking Iterator.java | 72 +++++++++++++++---------------------
 1 file changed, 30 insertions(+), 42 deletions(-)

diff --git a/Medium/Peeking Iterator.java b/Medium/Peeking Iterator.java
index 44edad63..3b1356e1 100644
--- a/Medium/Peeking Iterator.java	
+++ b/Medium/Peeking Iterator.java	
@@ -1,47 +1,35 @@
 // Java Iterator interface reference:
 // https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html
-import java.util.NoSuchElementException;
 
 class PeekingIterator implements Iterator<Integer> {
-
-    private Integer next;
-    private Iterator<Integer> iter;
-    private boolean noNextElement = false;
-    
-    public PeekingIterator(Iterator<Integer> iterator) {
-        // initialize any member here.
-        iter = iterator;
-        moveIterator();
-    }
-
-    // Returns the next element in the iteration without advancing the iterator.
-    public Integer peek() {
-        return next;
-    }
-
-    // hasNext() and next() should behave the same as in the Iterator interface.
-    // Override them if needed.
-    @Override
-    public Integer next() {
-        if (noNextElement) {
-            throw new NoSuchElementException();
-        }
-        Integer val = next;
-        moveIterator();
-        return val;   
-    }
-
-    @Override
-    public boolean hasNext() {
-        return !noNextElement;
-    }
-    
-    public void moveIterator() {
-        if (iter.hasNext()) {
-            next = iter.next();
-        }
-        else {
-            noNextElement = true;
-        }
-    }
+  Integer nextElement;
+  Iterator<Integer> iterator;
+	public PeekingIterator(Iterator<Integer> iterator) {
+    // initialize any member here.
+    this.iterator = iterator;
+    updateNext();
+	}
+  
+  private void updateNext() {
+    nextElement = iterator.hasNext() ? iterator.next() : null;
+  }
+	
+  // Returns the next element in the iteration without advancing the iterator.
+	public Integer peek() {
+    return nextElement;
+	}
+	
+	// hasNext() and next() should behave the same as in the Iterator interface.
+	// Override them if needed.
+	@Override
+	public Integer next() {
+    Integer returnValue = nextElement;
+    updateNext();
+    return returnValue;
+	}
+	
+	@Override
+	public boolean hasNext() {
+	  return nextElement != null;
+	}
 }

From de8a0dd6c43aeff436ce5099d5e462d02f1a1217 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Feb 2021 05:50:30 -0800
Subject: [PATCH 0455/2175] Update Peeking Iterator.java


From 19a2abebe7ce7da1d039deb55bfb8a3d45b8e8cb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Feb 2021 05:51:29 -0800
Subject: [PATCH 0456/2175] Update Peeking Iterator.java

---
 Medium/Peeking Iterator.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Medium/Peeking Iterator.java b/Medium/Peeking Iterator.java
index 3b1356e1..63ab64cb 100644
--- a/Medium/Peeking Iterator.java	
+++ b/Medium/Peeking Iterator.java	
@@ -4,20 +4,20 @@
 class PeekingIterator implements Iterator<Integer> {
   Integer nextElement;
   Iterator<Integer> iterator;
-	public PeekingIterator(Iterator<Integer> iterator) {
+  public PeekingIterator(Iterator<Integer> iterator) {
     // initialize any member here.
     this.iterator = iterator;
     updateNext();
-	}
+  }
   
   private void updateNext() {
     nextElement = iterator.hasNext() ? iterator.next() : null;
   }
 	
   // Returns the next element in the iteration without advancing the iterator.
-	public Integer peek() {
+  public Integer peek() {
     return nextElement;
-	}
+  }
 	
 	// hasNext() and next() should behave the same as in the Iterator interface.
 	// Override them if needed.

From f442fc8cef23ea7311682dce7a4a1d5bca1deaf0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Feb 2021 15:49:59 -0800
Subject: [PATCH 0457/2175] Added Maximum Score From Removing Stones.java

---
 .../Maximum Score From Removing Stones.java   | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Maximum Score From Removing Stones.java

diff --git a/Medium/Maximum Score From Removing Stones.java b/Medium/Maximum Score From Removing Stones.java
new file mode 100644
index 00000000..bdc88bcb
--- /dev/null
+++ b/Medium/Maximum Score From Removing Stones.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int maximumScore(int a, int b, int c) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+    pq.addAll(Arrays.asList(a, b, c));
+    int score = 0;
+    while (pq.size() > 1) {
+      int firstStoneCount = pq.remove();
+      int secondStoneCount = pq.remove();
+      if (firstStoneCount > 1) {
+        pq.add(firstStoneCount - 1);
+      }
+      if (secondStoneCount > 1) {
+        pq.add(secondStoneCount - 1);
+      }
+      score++;
+    }
+    return score;
+  }
+}

From d54d295fee9efeaf8cd5df91ee6e3a6814e61e7c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Feb 2021 06:15:21 -0800
Subject: [PATCH 0458/2175] Update and rename Convert BST to greater tree.java
 to Convert BST to Greater Tree.java

---
 Easy/Convert BST to Greater Tree.java | 36 +++++++++++++++++++++++++++
 Easy/Convert BST to greater tree.java | 26 -------------------
 2 files changed, 36 insertions(+), 26 deletions(-)
 create mode 100644 Easy/Convert BST to Greater Tree.java
 delete mode 100644 Easy/Convert BST to greater tree.java

diff --git a/Easy/Convert BST to Greater Tree.java b/Easy/Convert BST to Greater Tree.java
new file mode 100644
index 00000000..8a0ff782
--- /dev/null
+++ b/Easy/Convert BST to Greater Tree.java	
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode convertBST(TreeNode root) {
+    Stack<TreeNode> stack = new Stack<>();
+    addToStack(stack, root);
+    int currSum = 0;
+    while (!stack.isEmpty()) {
+      TreeNode removed = stack.pop();
+      currSum += removed.val;
+      removed.val = currSum;
+      addToStack(stack, removed.left);
+    }
+    return root;
+  }
+  
+  private void addToStack(Stack<TreeNode> stack, TreeNode node) {
+    while (node != null) {
+      stack.push(node);
+      node = node.right;
+    }
+  }
+}
diff --git a/Easy/Convert BST to greater tree.java b/Easy/Convert BST to greater tree.java
deleted file mode 100644
index f4b736f3..00000000
--- a/Easy/Convert BST to greater tree.java	
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-  int updatedVal = 0;
-  public TreeNode convertBST(TreeNode root) {
-    helper(root);
-    return root;
-  }
-  
-  private void helper(TreeNode root) {
-    if (root == null) {
-      return;
-    }
-    helper(root.right);
-    updatedVal += root.val;
-    root.val = updatedVal;
-    helper(root.left);
-  }
-}

From 121ca508d5a8c7b04fa84354e177d8d615e7a9a8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 10 Feb 2021 10:57:01 -0800
Subject: [PATCH 0459/2175] Refactored Copy List with Random Pointer.java

---
 Medium/Copy List with Random Pointer.java | 57 ++++++++++++-----------
 1 file changed, 31 insertions(+), 26 deletions(-)

diff --git a/Medium/Copy List with Random Pointer.java b/Medium/Copy List with Random Pointer.java
index f86d0155..333941a2 100644
--- a/Medium/Copy List with Random Pointer.java	
+++ b/Medium/Copy List with Random Pointer.java	
@@ -1,28 +1,33 @@
-/**
- * Definition for singly-linked list with a random pointer.
- * class RandomListNode {
- *     int label;
- *     RandomListNode next, random;
- *     RandomListNode(int x) { this.label = x; }
- * };
- */
-public class Solution {
-    public RandomListNode copyRandomList(RandomListNode head) {
-        if (head == null) {
-            return null;
-        }
-        
-        RandomListNode ans = new RandomListNode(head.label);
-        RandomListNode curr = ans;
-        
-        while (head != null) {
-            curr.next = head.next == null ? null : new RandomListNode(head.next.label);
-            curr.random = head.random == null ? null : new RandomListNode(head.random.label);
-            
-            curr = curr.next;
-            head = head.next;
-        }
-        
-        return ans;
+/*
+// Definition for a Node.
+class Node {
+    int val;
+    Node next;
+    Node random;
+
+    public Node(int val) {
+        this.val = val;
+        this.next = null;
+        this.random = null;
     }
 }
+*/
+
+class Solution {
+  public Node copyRandomList(Node head) {
+    Map<Node, Node> map = new HashMap<>();
+    Node curr = head;
+    while (curr != null) {
+      map.put(curr, new Node(curr.val));
+      curr = curr.next;
+    }
+    curr = head;
+    while (curr != null) {
+      Node temp = map.get(curr);
+      temp.next = curr.next == null ? null : map.get(curr.next);
+      temp.random = curr.random == null ? null : map.get(curr.random);
+      curr = curr.next;
+    }
+    return map.get(head);
+  }
+}

From 3adf66b5bbd600058284bdbe5af49a36ce82a894 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 Feb 2021 07:02:50 -0800
Subject: [PATCH 0460/2175] Refactored The K Weakest Rows in a Matrix.java

---
 Easy/The K Weakest Rows in a Matrix.java | 42 +++++++++---------------
 1 file changed, 15 insertions(+), 27 deletions(-)

diff --git a/Easy/The K Weakest Rows in a Matrix.java b/Easy/The K Weakest Rows in a Matrix.java
index 4da5a15e..09e395be 100644
--- a/Easy/The K Weakest Rows in a Matrix.java	
+++ b/Easy/The K Weakest Rows in a Matrix.java	
@@ -1,40 +1,28 @@
 class Solution {
   public int[] kWeakestRows(int[][] mat, int k) {
-    Map<Integer, Integer> map = new HashMap<>();
+    PriorityQueue<int[]> pq = new PriorityQueue<>(
+        Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[0]));
     for (int i = 0; i < mat.length; i++) {
-      map.put(i, getLastIndex(mat[i], 0, mat[i].length - 1) + 1);
+      pq.add(new int[]{i, getNumberOfOnes(mat[i])});
     }
-    PriorityQueue<Integer> pq = new PriorityQueue<Integer>(new Comparator<Integer>(){
-      public int compare(Integer o1, Integer o2) {
-        int c = map.get(o1) - map.get(o2);
-        if (c != 0) {
-          return c;
-        }
-        return o1 - o2;
-      }
-    });
-    for (int i = 0; i < mat.length; i++) {
-      pq.add(i);
-    }
-    int[] ans = new int[k];
-    for (int i = 0; i < k; i++) {
-      ans[i] = pq.poll();
+    int[] result = new int[k];
+    for (int i = 0; i < result.length && !pq.isEmpty(); i++) {
+      result[i] = pq.poll()[0];
     }
-    return ans;
+    return result;
   }
-  
-  private int getLastIndex(int[] arr, int start, int end) {
-    int idx = -1;
+
+  private int getNumberOfOnes(int[] arr) {
+    int start = 0;
+    int end = arr.length - 1;
     while (start <= end) {
       int mid = (start + end) / 2;
-      if (arr[mid] == 1) {
-        idx = Math.max(idx, mid);
-        start = mid + 1;
-      }
-      else {
+      if (arr[mid] == 0) {
         end = mid - 1;
+      } else {
+        start = mid + 1;
       }
     }
-    return idx;
+    return end < 0 ? 0 : start;
   }
 }

From d5dda98e3afdedb5bd19a5166db7b0cc8274d096 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 16 Feb 2021 06:38:30 -0800
Subject: [PATCH 0461/2175] Refactored Letter Case Permutation.java

---
 Easy/Letter Case Permutation.java | 33 +++++++++++++------------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/Easy/Letter Case Permutation.java b/Easy/Letter Case Permutation.java
index c451655c..eb1f7d74 100644
--- a/Easy/Letter Case Permutation.java	
+++ b/Easy/Letter Case Permutation.java	
@@ -1,29 +1,24 @@
 class Solution {
   public List<String> letterCasePermutation(String S) {
-    Set<String> set = new HashSet<>();
-    helper(S, 0, set, new StringBuilder());
-    return new ArrayList<>(set);
+    List<String> result = new ArrayList<>();
+    helper(S, 0, new StringBuilder(), result);
+    return result;
   }
   
-  private void helper(String s, int idx, Set<String> set, StringBuilder sb) {
+  private void helper(String s, int idx, StringBuilder sb, List<String> result) {
     if (idx == s.length()) {
-      if (sb.length() > 0) {
-        set.add(new StringBuilder(sb.toString()).toString());
-      }
-    }
-    else {
-      char c = s.charAt(idx);
-      if (Character.isDigit(c)) {
-        sb.append(c);
-        helper(s, idx + 1, set, sb);
+      result.add(new String(sb.toString()));
+    } else {
+      if (Character.isDigit(s.charAt(idx))) {
+        sb.append(s.charAt(idx));
+        helper(s, idx + 1, sb, result);
         sb.deleteCharAt(sb.length() - 1);
-      }
-      else {
-        sb.append(Character.toLowerCase(c));
-        helper(s, idx + 1, set, sb);
+      } else {
+        sb.append(Character.toLowerCase(s.charAt(idx)));
+        helper(s, idx + 1, sb, result);
         sb.deleteCharAt(sb.length() - 1);
-        sb.append(Character.toUpperCase(c));
-        helper(s, idx + 1, set, sb);
+        sb.append(Character.toUpperCase(s.charAt(idx)));
+        helper(s, idx + 1, sb, result);
         sb.deleteCharAt(sb.length() - 1);
       }
     }

From 65e2fbab510d8c524d1863d1b52a1511aca9851f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 17 Feb 2021 07:02:59 -0800
Subject: [PATCH 0462/2175] Refactored Container With Most Water.java

---
 Medium/Container With Most Water.java | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/Medium/Container With Most Water.java b/Medium/Container With Most Water.java
index fbdacebf..cbfacba0 100644
--- a/Medium/Container With Most Water.java	
+++ b/Medium/Container With Most Water.java	
@@ -1,19 +1,17 @@
 class Solution {
   public int maxArea(int[] height) {
+    int maxWater = 0;
     int start = 0;
     int end = height.length - 1;
-    int maxArea = 0;
     while (start < end) {
       int minHeight = Math.min(height[start], height[end]);
-      int dist = end - start;
-      maxArea = Math.max(maxArea, minHeight * dist);
+      maxWater = Math.max(maxWater, minHeight * (end - start));
       if (height[start] > height[end]) {
         end--;
-      }
-      else {
+      } else {
         start++;
       }
     }
-    return maxArea;
+    return maxWater;
   }
 }

From 8e9211e29a870a9e705f5b624b8512b6633f8060 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 17 Feb 2021 17:54:46 -0800
Subject: [PATCH 0463/2175] Added Count Number of Homogenous Substrings.java

---
 .../Count Number of Homogenous Substrings.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Count Number of Homogenous Substrings.java

diff --git a/Medium/Count Number of Homogenous Substrings.java b/Medium/Count Number of Homogenous Substrings.java
new file mode 100644
index 00000000..64dd8610
--- /dev/null
+++ b/Medium/Count Number of Homogenous Substrings.java	
@@ -0,0 +1,18 @@
+class Solution {
+  private final int MOD = 1000000007;
+  public int countHomogenous(String s) {
+    int count = 0;
+    int start = 0;
+    int end = 0;
+    int n = s.length();
+    while (end < n) {
+      if (s.charAt(start) == s.charAt(end)) {
+        count = (count + (end - start + 1)) % MOD;
+        end++;
+      } else {
+        start++;
+      }
+    }
+    return count;
+  }
+}

From be90aec7d382344e3d4d4728144d8da6bc08e24b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 18 Feb 2021 09:03:32 -0800
Subject: [PATCH 0464/2175] Refactored Arithmetic Slices.java

---
 Medium/Arithmetic Slices.java | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/Medium/Arithmetic Slices.java b/Medium/Arithmetic Slices.java
index 67a68778..3a9b3cd2 100644
--- a/Medium/Arithmetic Slices.java	
+++ b/Medium/Arithmetic Slices.java	
@@ -1,17 +1,15 @@
 class Solution {
   public int numberOfArithmeticSlices(int[] A) {
-    int count = 0;
-    for (int i = 0; i < A.length - 2; i++) {
+    int counter = 0;
+    int n = A.length;
+    for (int i = 0; i < n - 2; i++) {
       int diff = A[i + 1] - A[i];
-      for (int j = i + 2; j < A.length; j++) {
-        if (A[j] - A[j - 1] == diff) {
-          count++;
-        }
-        else {
-          break;
-        }
+      int nextIdx = i + 2;
+      while (nextIdx < n && A[nextIdx] - A[nextIdx - 1] == diff) {
+        nextIdx++;
       }
+      counter += nextIdx - i - 2;
     }
-    return count;
+    return counter;
   }
 }

From 7b018d0ee577ede68f666a43e6b77eb096a5885e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 18 Feb 2021 18:22:40 -0800
Subject: [PATCH 0465/2175] Added Minimum Changes To Make Alternating Binary
 String.java

---
 ...mum Changes To Make Alternating Binary String.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Minimum Changes To Make Alternating Binary String.java

diff --git a/Easy/Minimum Changes To Make Alternating Binary String.java b/Easy/Minimum Changes To Make Alternating Binary String.java
new file mode 100644
index 00000000..539d9a42
--- /dev/null
+++ b/Easy/Minimum Changes To Make Alternating Binary String.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int minOperations(String s) {
+    int numOfChanges = 0;
+    for (int i = 0; i < s.length(); i++) {
+      if (s.charAt(i) - '0' != i % 2) {
+        numOfChanges++;
+      }
+    }
+    return Math.min(numOfChanges, s.length() - numOfChanges);
+  }
+}

From a768c2ca36ad4c444d534f5c4b7fc8784f4e5847 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Feb 2021 17:53:43 -0800
Subject: [PATCH 0466/2175] Added Longest Nice Substring.java

---
 Easy/Longest Nice Substring.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Longest Nice Substring.java

diff --git a/Easy/Longest Nice Substring.java b/Easy/Longest Nice Substring.java
new file mode 100644
index 00000000..0795b833
--- /dev/null
+++ b/Easy/Longest Nice Substring.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public String longestNiceSubstring(String s) {
+    Set<Character> set = s.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (!(set.contains(Character.toLowerCase(c)) && set.contains(Character.toUpperCase(c)))) {
+        String left = longestNiceSubstring(s.substring(0, i));
+        String right = longestNiceSubstring(s.substring(i + 1));
+        return left.length() >= right.length() ? left : right; 
+      }
+    }
+    return s;
+  }
+}

From f9a8262d319b32e767a6279eb603560e0e7c2bc5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Feb 2021 06:45:15 -0800
Subject: [PATCH 0467/2175] Added Merge Strings Alternately.java

---
 Easy/Merge Strings Alternately.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Merge Strings Alternately.java

diff --git a/Easy/Merge Strings Alternately.java b/Easy/Merge Strings Alternately.java
new file mode 100644
index 00000000..65fb9904
--- /dev/null
+++ b/Easy/Merge Strings Alternately.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public String mergeAlternately(String word1, String word2) {
+    int idx1 = 0;
+    int idx2 = 0;
+    StringBuilder sb = new StringBuilder();
+    boolean first = true;
+    while (idx1 < word1.length() && idx2 < word2.length()) {
+      sb.append(first ? word1.charAt(idx1++) : word2.charAt(idx2++));
+      first = !first;
+    }
+    while (idx1 < word1.length()) {
+      sb.append(word1.charAt(idx1++));
+    }
+    while (idx2 < word2.length()) {
+      sb.append(word2.charAt(idx2++));
+    }
+    return sb.toString();
+  }
+}

From a3fefa01628a7729c959b39c542e5daab975f6cb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Feb 2021 10:21:03 -0800
Subject: [PATCH 0468/2175] Refactored Broken Calculator.java

---
 Medium/Broken Calculator.java | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/Medium/Broken Calculator.java b/Medium/Broken Calculator.java
index 9b89d8c0..a746211a 100644
--- a/Medium/Broken Calculator.java	
+++ b/Medium/Broken Calculator.java	
@@ -1,18 +1,10 @@
 class Solution {
-    public int brokenCalc(int X, int Y) {
-        int count = 0;
-        
-        while (Y > X) {
-            if (Y % 2 == 0) {
-                Y = Y / 2;
-            }
-            else {
-                Y++;
-            }
-            
-            count++;
-        }
-        
-        return count + X - Y;
+  public int brokenCalc(int X, int Y) {
+    int count = 0;
+    while (Y > X) {
+      count++;
+      Y = Y % 2 == 1 ? Y + 1 : Y / 2;
     }
+    return count + X - Y;
+  }
 }

From 37f01c696cefa881d7e5544f69d3360bcd32c828 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Feb 2021 16:09:30 -0800
Subject: [PATCH 0469/2175] Refactored Odd Even Linked Lists.java

---
 Medium/Odd Even Linked Lists.java | 33 +++++++++++++++++--------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/Medium/Odd Even Linked Lists.java b/Medium/Odd Even Linked Lists.java
index 4c4a1aae..2c8adf87 100644
--- a/Medium/Odd Even Linked Lists.java	
+++ b/Medium/Odd Even Linked Lists.java	
@@ -3,23 +3,26 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode oddEvenList(ListNode head) {
-        if(head == null || head.next == null)
-            return head;
-        ListNode odd = head;
-        ListNode even = head.next;
-        ListNode evenHead = even;
-        while(odd.next != null && even.next != null){
-            odd.next = even.next;
-            odd = odd.next;
-            even.next = odd.next;
-            even = even.next;
-        }
-        odd.next = evenHead;
-        return head;
+  public ListNode oddEvenList(ListNode head) {
+    if (head == null || head.next == null) {
+      return head;
     }
+    ListNode oddIdxNode = head;
+    ListNode evenIdxNodeStart = head.next;
+    ListNode evenIdxNode = evenIdxNodeStart;
+    while (evenIdxNode != null && evenIdxNode.next != null) {
+      oddIdxNode.next = evenIdxNode.next;
+      oddIdxNode = oddIdxNode.next;
+      evenIdxNode.next = oddIdxNode.next;
+      evenIdxNode = evenIdxNode.next;
+    }
+    oddIdxNode.next = evenIdxNodeStart;
+    return head;
+  }
 }

From f7604600923f9ef2fef8cab43511a1025cd2f77c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Feb 2021 16:09:51 -0800
Subject: [PATCH 0470/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 217b83c2..c16f1700 100644
--- a/README.md
+++ b/README.md
@@ -2,5 +2,5 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 800+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 850+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)

From 58ae069db4aff87d58ab052e65ee9e635207e297 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Feb 2021 08:52:15 -0800
Subject: [PATCH 0471/2175] Added Longest Word in Dictionary through
 Deleting.java

---
 ...t Word in Dictionary through Deleting.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Longest Word in Dictionary through Deleting.java

diff --git a/Medium/Longest Word in Dictionary through Deleting.java b/Medium/Longest Word in Dictionary through Deleting.java
new file mode 100644
index 00000000..5f09bd58
--- /dev/null
+++ b/Medium/Longest Word in Dictionary through Deleting.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public String findLongestWord(String s, List<String> d) {
+    d.sort((o1, o2) -> o1.length() != o2.length() ? Integer.compare(o2.length(), o1.length())
+        : o1.compareTo(o2));
+    for (String word : d) {
+      int wordIdx = 0;
+      int strIdx = 0;
+      while (strIdx < s.length() && wordIdx < word.length()) {
+        if (word.charAt(wordIdx) == s.charAt(strIdx)) {
+          wordIdx++;
+        }
+        strIdx++;
+      }
+      if (wordIdx == word.length()) {
+        return word;
+      }
+    }
+    return "";
+  }
+}

From 00ab1ba76cc4165b23797de169e980e6dc51a901 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Feb 2021 09:11:39 -0800
Subject: [PATCH 0472/2175] Refactored Score of Parentheses.java

---
 Medium/Score of Parentheses.java | 34 +++++++++++---------------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/Medium/Score of Parentheses.java b/Medium/Score of Parentheses.java
index 0366b58d..43851423 100644
--- a/Medium/Score of Parentheses.java	
+++ b/Medium/Score of Parentheses.java	
@@ -1,25 +1,15 @@
 class Solution {
-    public static int scoreOfParentheses(String S) {
-        Stack<String> st = new Stack<>();
-        for (int i=0; i<S.length(); i++) {
-            if (S.charAt(i) == '(') {
-                st.push(String.valueOf(S.charAt(i)));
-            }
-            else {
-                int num = 0;
-                while (!st.peek().equals("(")) {
-                    num += Integer.parseInt(st.pop());
-                }
-                st.pop();
-                st.push(num == 0 ? String.valueOf("1") : String.valueOf(2*num));
-            }
-        }
-
-        int ans = 0;
-        while (!st.empty()) {
-            ans += Integer.parseInt(st.pop());
-        }
-
-        return ans;
+  public int scoreOfParentheses(String S) {
+    Stack<Integer> stack = new Stack<>();
+    int currMultiplier = 0;
+    for (char c : S.toCharArray()) {
+      if (c == '(') {
+        stack.push(currMultiplier);
+        currMultiplier = 0;
+      } else {
+        currMultiplier = stack.pop() + Math.max(2 * currMultiplier, 1);
+      }
     }
+    return currMultiplier;
+  }
 }

From 53703d4f8e2095d2b7892b9b29c318a7121e1482 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 26 Feb 2021 12:39:25 -0800
Subject: [PATCH 0473/2175] Refactored Validate Stack Sequences.java

---
 Medium/Validate Stack Sequences.java | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/Medium/Validate Stack Sequences.java b/Medium/Validate Stack Sequences.java
index aa3c8470..a7535ce6 100644
--- a/Medium/Validate Stack Sequences.java	
+++ b/Medium/Validate Stack Sequences.java	
@@ -1,28 +1,22 @@
 class Solution {
   public boolean validateStackSequences(int[] pushed, int[] popped) {
-    int pushStart = 0;
-    int popStart = 0;
     Stack<Integer> stack = new Stack<>();
-    while (pushStart < pushed.length && popStart < popped.length) {
-      if (stack.isEmpty()) {
-        stack.push(pushed[pushStart++]);
-      }
-      else {
-        if (stack.peek() == popped[popStart]) {
-          stack.pop();
-          popStart++;
-        }
-        else {
-          stack.push(pushed[pushStart++]);
-        }
+    int pushedIdx = 0;
+    int poppedIdx = 0;
+    while (pushedIdx < pushed.length && poppedIdx < popped.length) {
+      if (!stack.isEmpty() && stack.peek() == popped[poppedIdx]) {
+        stack.pop();
+        poppedIdx++;
+      } else {
+        stack.push(pushed[pushedIdx++]);
       }
     }
-    while (popStart < popped.length) {
-      if (stack.peek() != popped[popStart]) {
+    while (poppedIdx < popped.length) {
+      if (stack.peek() != popped[poppedIdx]) {
         return false;
       }
+      poppedIdx++;
       stack.pop();
-      popStart++;
     }
     return true;
   }

From a9ca5672e438d3bd2fc856975c687e70c31ce23b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 27 Feb 2021 21:42:26 -0800
Subject: [PATCH 0474/2175] Added Count Items Matching a Rule.java

---
 Easy/Count Items Matching a Rule.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Easy/Count Items Matching a Rule.java

diff --git a/Easy/Count Items Matching a Rule.java b/Easy/Count Items Matching a Rule.java
new file mode 100644
index 00000000..3ce28691
--- /dev/null
+++ b/Easy/Count Items Matching a Rule.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public int countMatches(List<List<String>> items, String ruleKey, String ruleValue) {
+    int ruleIdx = ruleKey.equals("type") ? 0 : (ruleKey.equals("color") ? 1 : 2);
+    return (int) items.stream().filter(item -> item.get(ruleIdx).equals(ruleValue)).count();
+  }
+}

From 363aadca08ce27f8e4cca4da866fef4f864efabb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Feb 2021 10:42:59 -0800
Subject: [PATCH 0475/2175] Refactored Maximum Frequency Stack.java

---
 Hard/Maximum Frequency Stack.java | 48 +++++++++++++++++--------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/Hard/Maximum Frequency Stack.java b/Hard/Maximum Frequency Stack.java
index 726b5651..9acd4a53 100644
--- a/Hard/Maximum Frequency Stack.java	
+++ b/Hard/Maximum Frequency Stack.java	
@@ -1,26 +1,32 @@
 class FreqStack {
-    Map<Integer, Integer> map;
-    Map<Integer, Stack<Integer>> freqMap;
-    int maxFreq;
-    public FreqStack() {
-        freqMap = new HashMap<>();
-        map = new HashMap<>();
-        maxFreq = Integer.MIN_VALUE;
-    }
-
-    public void push(int x) {
-        map.put(x, map.getOrDefault(x, 0) + 1);
-        maxFreq = Math.max(maxFreq, map.get(x));
-        freqMap.computeIfAbsent(map.get(x), k -> new Stack<>()).push(x);
-    }
+  Map<Integer, Integer> valueToCurrentFrequency;
+  Map<Integer, Stack<Integer>> frequencyToValues;
+  int maxFrequency;
+  public FreqStack() {
+    valueToCurrentFrequency = new HashMap<>();
+    frequencyToValues = new HashMap<>();
+    maxFrequency = 1;
+  }
 
-    public int pop() {
-        int popped = freqMap.get(maxFreq).pop();
-        map.put(popped, map.get(popped) - 1);
-        if (freqMap.get(maxFreq).size() == 0) {
-            maxFreq--;
-        }
+  public void push(int x) {
+    valueToCurrentFrequency.put(x, valueToCurrentFrequency.getOrDefault(x, 0) + 1);
+    frequencyToValues.computeIfAbsent(valueToCurrentFrequency.get(x), k -> new Stack<>()).add(x);
+    maxFrequency = Math.max(maxFrequency, valueToCurrentFrequency.get(x));
+  }
 
-        return popped;
+  public int pop() {
+    int val = frequencyToValues.get(maxFrequency).pop();
+    valueToCurrentFrequency.put(val, valueToCurrentFrequency.getOrDefault(val, 0) - 1);
+    if (frequencyToValues.get(maxFrequency).isEmpty()) {
+      maxFrequency--;
     }
+    return val;
+  }
 }
+
+/**
+ * Your FreqStack object will be instantiated and called as such:
+ * FreqStack obj = new FreqStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ */

From d4bc7dac642669ac5c48a1cdf36f1bd59abde60a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 1 Mar 2021 08:55:24 -0800
Subject: [PATCH 0476/2175] Refactored Distribute Candies.java

---
 Easy/Distribute Candies.java | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/Easy/Distribute Candies.java b/Easy/Distribute Candies.java
index 65ff099e..0cad02b6 100644
--- a/Easy/Distribute Candies.java	
+++ b/Easy/Distribute Candies.java	
@@ -1,15 +1,8 @@
 class Solution {
-    public int distributeCandies(int[] candies) {
-        Map<Integer, Integer> count = new HashMap<>();
-        int unique = 0;
-        int n = candies.length;
-        for (int i=0;i<n;i++) {
-            if (!count.containsKey(candies[i])) {
-                unique++;
-            }
-            count.put(candies[i],1);
-        }
-
-        return unique > n/2 ? n/2 : unique;
-    }
+  public int distributeCandies(int[] candyType) {
+    return Math.min(
+      Arrays.stream(candyType).boxed().collect(Collectors.toSet()).size(),
+      candyType.length / 2
+    );
+  }
 }

From a61b451fd2f9cb89ae3aa2602e94d67a256ee682 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 2 Mar 2021 08:15:47 -0800
Subject: [PATCH 0477/2175] Refactored Set Mismatch.java to functional style

---
 Easy/Set Mismatch.java | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Easy/Set Mismatch.java b/Easy/Set Mismatch.java
index c75988bc..f18f0a5c 100644
--- a/Easy/Set Mismatch.java	
+++ b/Easy/Set Mismatch.java	
@@ -1,17 +1,14 @@
+import java.util.Map.Entry;
+
 class Solution {
   public int[] findErrorNums(int[] nums) {
-    Map<Integer, Integer> frequency = new HashMap<>();
-    for (int num : nums) {
-      frequency.put(num, frequency.getOrDefault(num, 0) + 1);
-    }
-    int[] ans = new int[2];
-    for (int idx = 1; idx <= nums.length; idx++) {
-      if (!frequency.containsKey(idx)) {
-        ans[1] = idx;
-      } else if (frequency.get(idx) > 1) {
-        ans[0] = idx;
-      }
-    }
-    return ans;
+    HashMap<Integer, Long> frequencyMap = Arrays.stream(nums).boxed()
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
+    return new int[]{
+        frequencyMap.entrySet().stream().filter(entry -> entry.getValue().equals(2L))
+            .map(Entry::getKey).findFirst().orElse(-1),
+        IntStream.range(1, nums.length + 1).boxed().filter(key -> !frequencyMap.containsKey(key))
+            .findFirst().orElse(-1)
+    };
   }
 }

From bcd77f6c01c53f2c10005b8dc987d40c9862ab89 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 3 Mar 2021 08:53:46 -0800
Subject: [PATCH 0478/2175] Update and rename Missing Numbers.java to Missing
 Number.java

---
 Easy/Missing Number.java  |  6 ++++++
 Easy/Missing Numbers.java | 21 ---------------------
 2 files changed, 6 insertions(+), 21 deletions(-)
 create mode 100644 Easy/Missing Number.java
 delete mode 100644 Easy/Missing Numbers.java

diff --git a/Easy/Missing Number.java b/Easy/Missing Number.java
new file mode 100644
index 00000000..5e9021db
--- /dev/null
+++ b/Easy/Missing Number.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public int missingNumber(int[] nums) {
+    return (nums.length * (nums.length + 1) / 2) - Arrays.stream(nums).boxed()
+        .reduce(0, Integer::sum);
+  }
+}
diff --git a/Easy/Missing Numbers.java b/Easy/Missing Numbers.java
deleted file mode 100644
index 88e09784..00000000
--- a/Easy/Missing Numbers.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-public class Solution {
-    public int missingNumber(int[] nums) {
-        Arrays.sort(nums);
-        if (nums.length > 1 && nums[0] == 0) {
-            for (int i=0;i<nums.length-1;i++) {
-                if (nums[i]-nums[i+1] != -1) {
-                    return nums[i] + 1;
-                }
-            }
-        }
-        else {
-            if (nums[0] == 0) {
-                return nums[0] +1;
-            }
-            else {
-                return 0;
-            }
-        }
-        return nums[nums.length-1] + 1;
-    }
-}
\ No newline at end of file

From 0cf730d405983c343492077c7c4c7914ad11198b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Mar 2021 05:50:59 -0800
Subject: [PATCH 0479/2175] Added Check if Binary String Has at Most One
 Segment of Ones.java

---
 ...tring Has at Most One Segment of Ones.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Check if Binary String Has at Most One Segment of Ones.java

diff --git a/Easy/Check if Binary String Has at Most One Segment of Ones.java b/Easy/Check if Binary String Has at Most One Segment of Ones.java
new file mode 100644
index 00000000..5c9f9f51
--- /dev/null
+++ b/Easy/Check if Binary String Has at Most One Segment of Ones.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public boolean checkOnesSegment(String s) {
+    boolean foundContiguousSegment = false;
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      int count = 0;
+      while (idx < n && s.charAt(idx) == '1') {
+        count++;
+        idx++;
+      }
+      if (count >= 1) {
+        if (foundContiguousSegment) {
+          return false;
+        }
+        foundContiguousSegment = true;
+      } else {
+        idx++;
+      }
+    }
+    return foundContiguousSegment;
+  }
+}

From 02c1c265a26bb31e88cc816b8a072c1aac2dcd84 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Mar 2021 07:05:47 -0800
Subject: [PATCH 0480/2175] Added Find Nearest Point That Has the Same X or Y
 Coordinate.java

---
 ...t That Has the Same X or Y Coordinate.java | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Easy/Find Nearest Point That Has the Same X or Y Coordinate.java

diff --git a/Easy/Find Nearest Point That Has the Same X or Y Coordinate.java b/Easy/Find Nearest Point That Has the Same X or Y Coordinate.java
new file mode 100644
index 00000000..4a1e5eb4
--- /dev/null
+++ b/Easy/Find Nearest Point That Has the Same X or Y Coordinate.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public int nearestValidPoint(int x, int y, int[][] points) {
+    int[] basePoint = new int[]{x, y};
+    return IntStream.range(0, points.length).mapToObj(i -> new Point(basePoint, i, points[i]))
+        .filter(
+            Point::isMatch)
+        .sorted(Comparator.comparingInt(Point::getManhattanDistance).thenComparing(Point::getIdx))
+        .map(Point::getIdx).findFirst().orElse(-1);
+  }
+
+  private static class Point {
+    int[] basePoint;
+    int idx;
+    int[] currPoint;
+
+    public Point(int[] basePoint, int idx, int[] currPoint) {
+      this.basePoint = basePoint;
+      this.idx = idx;
+      this.currPoint = currPoint;
+    }
+
+    public int getIdx() {
+      return idx;
+    }
+
+    public int getManhattanDistance() {
+      return Math.abs(currPoint[0] - basePoint[0]) + Math.abs(currPoint[1] - basePoint[1]);
+    }
+
+    public boolean isMatch() {
+      return currPoint[0] == basePoint[0] || currPoint[1] == basePoint[1];
+    }
+  }
+}

From c8433f6979eae00122ce5c09753747abe27b047a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 10 Mar 2021 06:25:07 -0800
Subject: [PATCH 0481/2175] Refactored Integer To Roman.java

---
 Medium/Integer To Roman.java | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/Medium/Integer To Roman.java b/Medium/Integer To Roman.java
index 327be29a..cbc5aead 100644
--- a/Medium/Integer To Roman.java	
+++ b/Medium/Integer To Roman.java	
@@ -1,17 +1,15 @@
 class Solution {
-    public String intToRoman(int num) {
-        int[] values = {1000,900,500,400,100,90,50,40,10,9,5,4,1};
-        String[] strs = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
-    
-        StringBuilder sb = new StringBuilder();
-        
-        for (int i = 0; i < values.length; i++) {
-            while (num >= values[i]) {
-                num -= values[i];
-                sb.append(strs[i]);
-            }
-        }
-        
-        return sb.toString();
+  public String intToRoman(int num) {
+    int[] divisor = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+    String[] numerals = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < divisor.length; i++) {
+      int fact = num / divisor[i];
+      while (fact-- > 0) {
+        sb.append(numerals[i]);
+      }
+      num = num % divisor[i];
     }
+    return sb.toString();
+  }
 }

From eb2a473ec64e5ae4ccfcaf0f7d428f1cdec22026 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 13 Mar 2021 14:45:22 -0800
Subject: [PATCH 0482/2175] Add Check If a String Contains All Binary Codes of
 Size K.java

---
 ...ing Contains All Binary Codes of Size K.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Check If a String Contains All Binary Codes of Size K.java

diff --git a/Medium/Check If a String Contains All Binary Codes of Size K.java b/Medium/Check If a String Contains All Binary Codes of Size K.java
new file mode 100644
index 00000000..d202d57c
--- /dev/null
+++ b/Medium/Check If a String Contains All Binary Codes of Size K.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean hasAllCodes(String s, int k) {
+    Set<String> set = new HashSet<>();
+    int counter = 1 << k;
+    for (int i = k; i <= s.length(); i++) {
+      String temp = s.substring(i - k, i);
+      if (!set.contains(temp)) {
+        set.add(temp);
+        counter--;
+      }
+      if (counter == 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

From 3c00860d10084dd8b55fb71dc20b85b73847e714 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 14 Mar 2021 10:10:21 -0700
Subject: [PATCH 0483/2175] Added Check if One String Swap Can Make Strings
 Equal.java

---
 ...ne String Swap Can Make Strings Equal.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Check if One String Swap Can Make Strings Equal.java

diff --git a/Easy/Check if One String Swap Can Make Strings Equal.java b/Easy/Check if One String Swap Can Make Strings Equal.java
new file mode 100644
index 00000000..6b12d855
--- /dev/null
+++ b/Easy/Check if One String Swap Can Make Strings Equal.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public final int UNSET_INDEX = -1;
+  public final int SET_INDEX = 101;
+  public boolean areAlmostEqual(String s1, String s2) {
+    int swapIndex = UNSET_INDEX;
+    for (int i = 0; i < s1.length(); i++) {
+      if (s1.charAt(i) != s2.charAt(i)) {
+        if (swapIndex == SET_INDEX) {
+          return false;
+        } else if (swapIndex == UNSET_INDEX) {
+          swapIndex = i;
+        } else {
+          if (!(s1.charAt(swapIndex) == s2.charAt(i) && s1.charAt(i) == s2.charAt(swapIndex))) {
+            return false;
+          }
+          swapIndex = SET_INDEX;
+        }
+      }
+    }
+    return swapIndex == UNSET_INDEX || swapIndex == SET_INDEX;
+  }
+}

From d562796de13fb55ba653be3c09ebb2bd15cff307 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 14 Mar 2021 12:35:54 -0700
Subject: [PATCH 0484/2175] Added Find Center of Star Graph.java

---
 Medium/Find Center of Star Graph.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Find Center of Star Graph.java

diff --git a/Medium/Find Center of Star Graph.java b/Medium/Find Center of Star Graph.java
new file mode 100644
index 00000000..f3f6de5a
--- /dev/null
+++ b/Medium/Find Center of Star Graph.java	
@@ -0,0 +1,13 @@
+import java.util.Map.Entry;
+
+class Solution {
+  public int findCenter(int[][] edges) {
+    Map<Integer, Set<Integer>> map = new HashMap<>();
+    for (int[] edge : edges) {
+      map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+      map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    }
+    return map.entrySet().stream().filter(entry -> entry.getValue().size() == edges.length).map(
+        Entry::getKey).findFirst().orElse(-1);
+  }
+}

From d0e4802117d39dae37466cb52275affb7dd64480 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Mar 2021 18:39:25 -0700
Subject: [PATCH 0485/2175] Added Second Largest Digit in a String.java

---
 Easy/Second Largest Digit in a String.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Second Largest Digit in a String.java

diff --git a/Easy/Second Largest Digit in a String.java b/Easy/Second Largest Digit in a String.java
new file mode 100644
index 00000000..c4930136
--- /dev/null
+++ b/Easy/Second Largest Digit in a String.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int secondHighest(String s) {
+    int maximumNum = -1;
+    int secondMaximumNum = -1;
+    for (char c : s.toCharArray()) {
+      if (Character.isDigit(c)) {
+        int num = Character.getNumericValue(c);
+        if (maximumNum < num) {
+          if (secondMaximumNum < maximumNum) {
+            secondMaximumNum = maximumNum;
+          }
+          maximumNum = num;
+        } else if (secondMaximumNum < num && num < maximumNum) {
+          secondMaximumNum = num;
+        }
+      }
+    }
+    return secondMaximumNum;
+  }
+}

From 6b7bd7d4d0cc0137269e7f31efafd8ebd66ada93 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Mar 2021 09:08:03 -0700
Subject: [PATCH 0486/2175] Added Maximum Ascending Subarray Sum.java

---
 Easy/Maximum Ascending Subarray Sum.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Maximum Ascending Subarray Sum.java

diff --git a/Easy/Maximum Ascending Subarray Sum.java b/Easy/Maximum Ascending Subarray Sum.java
new file mode 100644
index 00000000..fb436414
--- /dev/null
+++ b/Easy/Maximum Ascending Subarray Sum.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int maxAscendingSum(int[] nums) {
+    int maximumSum = 0;
+    int idx = 0;
+    while (idx < nums.length) {
+      int currSum = nums[idx++];
+      while (idx < nums.length && nums[idx] > nums[idx - 1]) {
+        currSum += nums[idx++];
+      }
+      maximumSum = Math.max(maximumSum, currSum);
+    }
+    return maximumSum;
+  }
+}

From e656aca54698a3d0dcf204a0599bbc968cc3c697 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Mar 2021 18:19:36 -0700
Subject: [PATCH 0487/2175] Added Design Authentication Manager.java

---
 Medium/Design Authentication Manager.java | 33 +++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 Medium/Design Authentication Manager.java

diff --git a/Medium/Design Authentication Manager.java b/Medium/Design Authentication Manager.java
new file mode 100644
index 00000000..93071b1d
--- /dev/null
+++ b/Medium/Design Authentication Manager.java	
@@ -0,0 +1,33 @@
+class AuthenticationManager {
+
+  Map<String, Integer> map;
+  int timeToLive;
+
+  public AuthenticationManager(int timeToLive) {
+    map = new HashMap<>();
+    this.timeToLive = timeToLive;
+  }
+
+  public void generate(String tokenId, int currentTime) {
+    map.put(tokenId, currentTime);
+  }
+
+  public void renew(String tokenId, int currentTime) {
+    if (map.containsKey(tokenId) && map.get(tokenId) + timeToLive > currentTime) {
+      map.put(tokenId, currentTime);
+    }
+  }
+
+  public int countUnexpiredTokens(int currentTime) {
+    return (int) map.entrySet().stream()
+        .filter(entry -> entry.getValue() + timeToLive > currentTime).count();
+  }
+}
+
+/**
+ * Your AuthenticationManager object will be instantiated and called as such:
+ * AuthenticationManager obj = new AuthenticationManager(timeToLive);
+ * obj.generate(tokenId,currentTime);
+ * obj.renew(tokenId,currentTime);
+ * int param_3 = obj.countUnexpiredTokens(currentTime);
+ */

From b2072a495a77787a5fce320535f31751c02dda59 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Mar 2021 07:07:26 -0700
Subject: [PATCH 0488/2175] Added Advantage Shuffle.java

---
 Medium/Advantage Shuffle.java | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Advantage Shuffle.java

diff --git a/Medium/Advantage Shuffle.java b/Medium/Advantage Shuffle.java
new file mode 100644
index 00000000..2bb3ba9b
--- /dev/null
+++ b/Medium/Advantage Shuffle.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public int[] advantageCount(int[] A, int[] B) {
+    TreeMap<Integer, Integer> map = new TreeMap<>();
+    for (int num : A) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    int[] result = new int[A.length];
+    Arrays.fill(result, Integer.MIN_VALUE);
+    List<Integer> indexesNotPopulated = new ArrayList<>();
+    for (int i = 0; i < B.length; i++) {
+      Integer upper = map.higherKey(B[i]);
+      if (upper != null) {
+        result[i] = upper;
+        map.put(upper, map.get(upper) - 1);
+        if (map.get(upper) == 0) {
+          map.remove(upper);
+        }
+      } else {
+        indexesNotPopulated.add(i);
+      }
+    }
+    Iterator<Integer> iterator = indexesNotPopulated.iterator();
+    for (Integer key : map.keySet()) {
+      int value = map.get(key);
+      while (value-- > 0) {
+        result[iterator.next()] = key;
+      }
+    }
+    return result;
+  }
+}

From 949137536c60652467d02e50fe422f84df48ee64 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 27 Mar 2021 23:23:32 -0700
Subject: [PATCH 0489/2175] Added Number of Different Integers in a String.java

---
 ...mber of Different Integers in a String.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Number of Different Integers in a String.java

diff --git a/Easy/Number of Different Integers in a String.java b/Easy/Number of Different Integers in a String.java
new file mode 100644
index 00000000..3cdd6557
--- /dev/null
+++ b/Easy/Number of Different Integers in a String.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int numDifferentIntegers(String word) {
+    Set<Integer> set = new HashSet<>();
+    int idx = 0;
+    int n = word.length(); 
+    while (idx < n) {
+      if (Character.isDigit(word.charAt(idx))) {
+        int num = 0;
+        while (idx < n && Character.isDigit(word.charAt(idx))) {
+          num = num * 10 + Character.getNumericValue(word.charAt(idx++));
+        }
+        set.add(num);
+      } 
+      idx++;
+    }
+    return set.size();
+  }
+}

From f48cd08ea3253c8e22301e1b67be348c7ee3e29c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 4 Apr 2021 20:01:04 -0700
Subject: [PATCH 0490/2175] Added Truncate Sentence.java

---
 Easy/Truncate Sentence.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Truncate Sentence.java

diff --git a/Easy/Truncate Sentence.java b/Easy/Truncate Sentence.java
new file mode 100644
index 00000000..3b910dac
--- /dev/null
+++ b/Easy/Truncate Sentence.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public String truncateSentence(String s, int k) {
+    int idx = 0;
+    while (idx < s.length() && k > 0) {
+      if (s.charAt(idx) == ' ') {
+        k--;
+      }
+      idx++;
+    }
+    return s.substring(0, (idx == s.length() ? idx : idx - 1));
+  }
+}

From fd23399f3f48237072b24e4a2f0b8771096c8d0a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 5 Apr 2021 07:10:56 -0700
Subject: [PATCH 0491/2175] Added Determine Color of a Chessboard Square.java

---
 Easy/Determine Color of a Chessboard Square.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Determine Color of a Chessboard Square.java

diff --git a/Easy/Determine Color of a Chessboard Square.java b/Easy/Determine Color of a Chessboard Square.java
new file mode 100644
index 00000000..c18cab14
--- /dev/null
+++ b/Easy/Determine Color of a Chessboard Square.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public boolean squareIsWhite(String coordinates) {
+    return (
+        ("aceg".indexOf(coordinates.charAt(0)) != -1
+            && Character.getNumericValue(coordinates.charAt(1)) % 2 == 0) ||
+            ("aceg".indexOf(coordinates.charAt(0)) == -1
+                && Character.getNumericValue(coordinates.charAt(1)) % 2 != 0)
+    );
+  }
+}

From e24c5a6968774015b5c20d73dcc948f6541e0546 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 6 Apr 2021 17:59:03 -0700
Subject: [PATCH 0492/2175] Added Finding the Users Active Minutes.java

---
 Medium/Finding the Users Active Minutes.java | 24 ++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Finding the Users Active Minutes.java

diff --git a/Medium/Finding the Users Active Minutes.java b/Medium/Finding the Users Active Minutes.java
new file mode 100644
index 00000000..40d877af
--- /dev/null
+++ b/Medium/Finding the Users Active Minutes.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public int[] findingUsersActiveMinutes(int[][] logs, int k) {
+    Map<Integer, Set<Integer>> map = new HashMap<>();
+    List<Set<Integer>> setList = new ArrayList<>();
+    for (int i = 0; i < k; i++) {
+      setList.add(new HashSet<>());
+    }
+    for (int[] log : logs) {
+      map.computeIfAbsent(log[0], j -> new HashSet<>()).add(log[1]);
+      int currActiveTime = map.get(log[0]).size();
+      if (currActiveTime <= k) {
+        setList.get(currActiveTime - 1).add(log[0]);
+        if (currActiveTime != 1) {
+          setList.get(currActiveTime - 2).remove(log[0]);
+        }
+      }
+    }
+    int[] ans = new int[k];
+    for (int i = 0; i < k; i++) {
+      ans[i] = setList.get(i).size();
+    }
+    return ans;
+  }
+}

From d4ba40369a2ecdebd86445dded5414fdd8b62df9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Apr 2021 20:01:20 -0700
Subject: [PATCH 0493/2175] Added Sentence Similarity III.java

---
 Medium/Sentence Similarity III.java | 31 +++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Sentence Similarity III.java

diff --git a/Medium/Sentence Similarity III.java b/Medium/Sentence Similarity III.java
new file mode 100644
index 00000000..e85bb024
--- /dev/null
+++ b/Medium/Sentence Similarity III.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public boolean areSentencesSimilar(String sentence1, String sentence2) {
+    return isSimilar(sentence1.split(" "), sentence2.split(" ")) || isSimilar(sentence2.split(" "),
+        sentence1.split(" "));
+  }
+
+  private boolean isSimilar(String[] matcher, String[] target) {
+    int targetStartIdx = 0;
+    int matcherCurrentIdx = 0;
+    while (targetStartIdx < target.length && matcherCurrentIdx < matcher.length) {
+      if (!matcher[matcherCurrentIdx].equals(target[targetStartIdx])) {
+        break;
+      }
+      targetStartIdx++;
+      matcherCurrentIdx++;
+    }
+    if (targetStartIdx == target.length) {
+      return true;
+    }
+    int targetEndIdx = target.length - 1;
+    matcherCurrentIdx = matcher.length - 1;
+    while (targetEndIdx >= targetStartIdx && matcherCurrentIdx >= 0) {
+      if (!matcher[matcherCurrentIdx].equals(target[targetEndIdx])) {
+        return false;
+      }
+      targetEndIdx--;
+      matcherCurrentIdx--;
+    }
+    return targetEndIdx == targetStartIdx - 1;
+  }
+}

From 35d4f2f3aa0132653855cd145e77f3475e63ec29 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 10 Apr 2021 21:31:39 -0700
Subject: [PATCH 0494/2175] Added Sign of the Product of an Array.java

---
 Easy/Sign of the Product of an Array.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Easy/Sign of the Product of an Array.java

diff --git a/Easy/Sign of the Product of an Array.java b/Easy/Sign of the Product of an Array.java
new file mode 100644
index 00000000..bbd0d67d
--- /dev/null
+++ b/Easy/Sign of the Product of an Array.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public int arraySign(int[] nums) {
+    return Arrays.stream(nums).filter(num -> num == 0).map(e -> 0).findAny()
+        .orElse(Arrays.stream(nums).filter(num -> num < 0).count() % 2 == 0 ? 1 : -1);
+  }
+}

From c10ed38df5046bee41f940c42fb3136105e4a231 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Apr 2021 08:12:13 -0700
Subject: [PATCH 0495/2175] Update Deepest Leaves Sum.java

---
 Medium/Deepest Leaves Sum.java | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/Medium/Deepest Leaves Sum.java b/Medium/Deepest Leaves Sum.java
index 82138314..df67a081 100644
--- a/Medium/Deepest Leaves Sum.java	
+++ b/Medium/Deepest Leaves Sum.java	
@@ -4,29 +4,30 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  Map<Integer, Integer> map;
-  int deepestLevel;
   public int deepestLeavesSum(TreeNode root) {
-    map = new HashMap<>();
-    deepestLevel = 0;
-    helper(root, 0);
-    return map.get(deepestLevel);
+    Map<Integer, Integer> map = new HashMap<>();
+    helper(root, 0, map);
+    return map.getOrDefault(
+      map.keySet().stream().mapToInt(Integer::valueOf).max().orElse(0), 0
+    );
   }
   
-  private void helper(TreeNode root, int level) {
+  private void helper(TreeNode root, int currLevel, Map<Integer, Integer> map) {
     if (root == null) {
       return;
     }
-    if (root.left == null && root.right == null) {
-      map.put(level, map.getOrDefault(level, 0) + root.val);
-      deepestLevel = Math.max(deepestLevel, level);
-      return;
-    }
-    helper(root.left, level + 1);
-    helper(root.right, level + 1);
+    map.put(currLevel, map.getOrDefault(currLevel, 0) + root.val);
+    helper(root.left, currLevel + 1, map);
+    helper(root.right, currLevel + 1, map);
   }
 }

From 4e3224d7a4f505865e1ad1b5bfc29b4d1bae47d2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 14 Apr 2021 14:49:46 -0700
Subject: [PATCH 0496/2175] Update Flatten Nested List Iterator.java

---
 Medium/Flatten Nested List Iterator.java | 53 +++++++++---------------
 1 file changed, 20 insertions(+), 33 deletions(-)

diff --git a/Medium/Flatten Nested List Iterator.java b/Medium/Flatten Nested List Iterator.java
index 0a54bc02..30006429 100644
--- a/Medium/Flatten Nested List Iterator.java	
+++ b/Medium/Flatten Nested List Iterator.java	
@@ -11,52 +11,39 @@
  *     public Integer getInteger();
  *
  *     // @return the nested list that this NestedInteger holds, if it holds a nested list
- *     // Return null if this NestedInteger holds a single integer
+ *     // Return empty list if this NestedInteger holds a single integer
  *     public List<NestedInteger> getList();
  * }
  */
 public class NestedIterator implements Iterator<Integer> {
-  List<NestedInteger> nestedList;
-  Queue<Integer> queue;
-  int idx;
+
+  private Stack<NestedInteger> stack;
+  
   public NestedIterator(List<NestedInteger> nestedList) {
-    this.nestedList = nestedList;
-    queue = new LinkedList<>();
-    idx = 0;
-    addToQueue();
+    stack = new Stack<>();
+    for (int i = nestedList.size() - 1; i >= 0; i--) {
+      stack.push(nestedList.get(i));
+    }
   }
 
   @Override
   public Integer next() {
-    int val = queue.remove();
-    if (queue.isEmpty()) {
-      if (idx != nestedList.size()) {
-        addToQueue();
-      }
-    }
-    return val;
-  }
-  
-  private void addToQueue() {
-    while (idx < nestedList.size() && queue.isEmpty()) {
-      addToQueueHelper(nestedList.get(idx++));
-    }
+    return stack.pop().getInteger();
   }
   
-  private void addToQueueHelper(NestedInteger ns) {
-    if (ns.isInteger()) {
-      queue.add(ns.getInteger());
-    }
-    else {
-      for (NestedInteger ni : ns.getList()) {
-        addToQueueHelper(ni);
-      }
-    }
-  }
-
   @Override
   public boolean hasNext() {
-    return !(queue.isEmpty() && idx == nestedList.size());
+    while (!stack.isEmpty() && !stack.peek().isInteger()) {
+      NestedInteger popped = stack.pop();
+      if (popped == null) {
+        continue;
+      }
+      List<NestedInteger> list = popped.getList();
+      for (int i = list.size() - 1; i >= 0; i--) {
+        stack.push(list.get(i));
+      }
+    }
+    return !stack.isEmpty();
   }
 }
 

From 0dcf0bc463db2952399d2b30a8ee7a1e27a01d9e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 17 Apr 2021 10:09:27 -0700
Subject: [PATCH 0497/2175] Added Minimum Operations to Make the Array
 Increasing.java

---
 ...m Operations to Make the Array Increasing.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Minimum Operations to Make the Array Increasing.java

diff --git a/Easy/Minimum Operations to Make the Array Increasing.java b/Easy/Minimum Operations to Make the Array Increasing.java
new file mode 100644
index 00000000..99bdf2f7
--- /dev/null
+++ b/Easy/Minimum Operations to Make the Array Increasing.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int minOperations(int[] nums) {
+    int prev = nums[0];
+    int totalOperations = 0;
+    for (int i = 1; i < nums.length; i++) {
+      if (nums[i] <= prev) {
+        totalOperations += prev - nums[i] + 1;
+        prev++;
+      } else {
+        prev = nums[i];
+      }
+    }
+    return totalOperations;
+  }
+}

From be7be69ffb50566303a88165c93b23d94e0fcf26 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Apr 2021 06:36:28 -0700
Subject: [PATCH 0498/2175] Check if the Sentence Is Pangram.java

---
 Easy/Check if the Sentence Is Pangram.java | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Easy/Check if the Sentence Is Pangram.java

diff --git a/Easy/Check if the Sentence Is Pangram.java b/Easy/Check if the Sentence Is Pangram.java
new file mode 100644
index 00000000..ad74e7a0
--- /dev/null
+++ b/Easy/Check if the Sentence Is Pangram.java	
@@ -0,0 +1,7 @@
+class Solution {
+  public boolean checkIfPangram(String sentence) {
+    Set<Character> allUnique = sentence.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
+    return "abcdefghijklmnopqrstuvwxyz".chars().mapToObj(c -> (char) c)
+        .allMatch(allUnique::contains);
+  }
+}

From ac3f601f9268b2523d9489c4d4e51eec88631519 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Apr 2021 06:43:42 -0700
Subject: [PATCH 0499/2175] Update Check if the Sentence Is Pangram.java

---
 Easy/Check if the Sentence Is Pangram.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Easy/Check if the Sentence Is Pangram.java b/Easy/Check if the Sentence Is Pangram.java
index ad74e7a0..a7d7b8e8 100644
--- a/Easy/Check if the Sentence Is Pangram.java	
+++ b/Easy/Check if the Sentence Is Pangram.java	
@@ -1,7 +1,5 @@
 class Solution {
   public boolean checkIfPangram(String sentence) {
-    Set<Character> allUnique = sentence.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
-    return "abcdefghijklmnopqrstuvwxyz".chars().mapToObj(c -> (char) c)
-        .allMatch(allUnique::contains);
+    return sentence.chars().mapToObj(c -> (char) c).collect(Collectors.toSet()).size() == 26;
   }
 }

From 675c0dc75735fdb5149dc31b53f45f551ccbb36d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Apr 2021 19:18:32 -0700
Subject: [PATCH 0500/2175] Added Maximum Ice Cream Bars.java

---
 Medium/Maximum Ice Cream Bars.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Maximum Ice Cream Bars.java

diff --git a/Medium/Maximum Ice Cream Bars.java b/Medium/Maximum Ice Cream Bars.java
new file mode 100644
index 00000000..75d34abf
--- /dev/null
+++ b/Medium/Maximum Ice Cream Bars.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int maxIceCream(int[] costs, int coins) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    pq.addAll(Arrays.stream(costs).boxed().collect(Collectors.toList()));
+    int icecreamCount = 0;
+    while (!pq.isEmpty() && (coins - pq.peek()) >= 0) {
+      coins -= pq.poll();
+      icecreamCount++;
+    }
+    return icecreamCount;
+  }
+}

From a886cc4b5b0a458479fb83b7d5250a0825b3fea9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Apr 2021 08:16:04 -0700
Subject: [PATCH 0501/2175] Update N-ary Tree Preorder Traversal.java

---
 Easy/N-ary Tree Preorder Traversal.java | 56 ++++++++++---------------
 1 file changed, 21 insertions(+), 35 deletions(-)

diff --git a/Easy/N-ary Tree Preorder Traversal.java b/Easy/N-ary Tree Preorder Traversal.java
index 73d61d32..49fac382 100644
--- a/Easy/N-ary Tree Preorder Traversal.java	
+++ b/Easy/N-ary Tree Preorder Traversal.java	
@@ -6,47 +6,33 @@ class Node {
 
     public Node() {}
 
-    public Node(int _val,List<Node> _children) {
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
         val = _val;
         children = _children;
     }
 };
 */
-class Solution {
-    List<Integer> values = new ArrayList<>();
-    public List<Integer> preorder(Node root) {
-        updateListIterative(root);
-        return values;
-    }
-    
-    private void updateListIterative(Node root) {
-        if (root == null) {
-            return;
-        }
-        
-        Stack<Node> stack = new Stack<>();
-        stack.push(root);
 
-        while (!stack.empty()) {
-            Node temp = stack.pop();
-            values.add(temp.val);
-            
-            List<Node> childrens = temp.children;
-            
-            for (int i=childrens.size()-1; i>=0; i--) {
-                stack.push(childrens.get(i));
-            }
-        }
+class Solution {
+  public List<Integer> preorder(Node root) {
+    if (root == null) {
+      return new ArrayList<>();
     }
-    
-    private void updateListRecursive(Node root) {
-        if (root == null) {
-            return;
-        }
-        
-        values.add(root.val);
-        for (Node node : root.children) {
-            updateListRecursive(node);
-        }
+    List<Integer> list = new ArrayList<>();
+    Stack<Node> stack = new Stack<>();
+    stack.push(root);
+    while (!stack.isEmpty()) {
+      Node popped = stack.pop();
+      list.add(popped.val);
+      List<Node> children = popped.children;
+      for (int i = children.size() - 1; i >= 0; i--) {
+        stack.push(children.get(i));
+      }
     }
+    return list;
+  }
 }

From 3744abb7bd12769c11dabcc64dda26c2a8928a5d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Apr 2021 19:08:04 -0700
Subject: [PATCH 0502/2175] Added Sum of Digits in Base K.java

---
 Easy/Sum of Digits in Base K.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Sum of Digits in Base K.java

diff --git a/Easy/Sum of Digits in Base K.java b/Easy/Sum of Digits in Base K.java
new file mode 100644
index 00000000..9775701b
--- /dev/null
+++ b/Easy/Sum of Digits in Base K.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public int sumBase(int n, int k) {
+    int digitSum = 0;
+    while (n > 0) {
+      digitSum += n % k;
+      n /= k;
+    }
+    return digitSum;
+  }
+}

From 35a2f55e70a6e6cf84fa73aac0bec663d2ae1019 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 27 Apr 2021 07:36:52 -0700
Subject: [PATCH 0503/2175] Update and rename Power of three.java to Power of
 Three.java

---
 Easy/Power of Three.java | 14 ++++++++++++++
 Easy/Power of three.java |  5 -----
 2 files changed, 14 insertions(+), 5 deletions(-)
 create mode 100644 Easy/Power of Three.java
 delete mode 100644 Easy/Power of three.java

diff --git a/Easy/Power of Three.java b/Easy/Power of Three.java
new file mode 100644
index 00000000..b93756c6
--- /dev/null
+++ b/Easy/Power of Three.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public boolean isPowerOfThree(int n) {
+    if (n <= 0) {
+      return false;
+    }
+    while (n > 1) {
+      if (n % 3 != 0) {
+        return false;
+      }
+      n /= 3;
+    }
+    return true;
+  }
+}
diff --git a/Easy/Power of three.java b/Easy/Power of three.java
deleted file mode 100644
index 4e99c550..00000000
--- a/Easy/Power of three.java	
+++ /dev/null
@@ -1,5 +0,0 @@
-class Solution {
-    public boolean isPowerOfThree(int n) {
-        return n>0 &&  1162261467%n==0;
-    }
-}

From 2fdbcabd712d407730ff9a7d76ff7ace1b041c1d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 1 May 2021 11:49:45 -0700
Subject: [PATCH 0504/2175] Added Replace All Digits with Characters.java

---
 Easy/Replace All Digits with Characters.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Replace All Digits with Characters.java

diff --git a/Easy/Replace All Digits with Characters.java b/Easy/Replace All Digits with Characters.java
new file mode 100644
index 00000000..92047d4e
--- /dev/null
+++ b/Easy/Replace All Digits with Characters.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public String replaceDigits(String s) {
+    StringBuilder sb = new StringBuilder();
+    int n = s.length();
+    for (int i = 1; i < n; i += 2) {
+      char c = s.charAt(i - 1);
+      sb.append(c).append((char) (((int) c) + Character.getNumericValue(s.charAt(i))));
+    }
+    return n % 2 != 0 ? sb.append(s.charAt(n - 1)).toString() : sb.toString();
+  }
+}

From 588a3e1fd8d9ed712372a7087372b2f85d558da5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 1 May 2021 21:00:40 -0700
Subject: [PATCH 0505/2175] Added Seat Reservation Manager.java

---
 Medium/Seat Reservation Manager.java | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Seat Reservation Manager.java

diff --git a/Medium/Seat Reservation Manager.java b/Medium/Seat Reservation Manager.java
new file mode 100644
index 00000000..d8825a61
--- /dev/null
+++ b/Medium/Seat Reservation Manager.java	
@@ -0,0 +1,28 @@
+class SeatManager {
+
+  PriorityQueue<Integer> pq;
+  int count;
+
+  public SeatManager(int n) {
+    pq = new PriorityQueue<>();
+    count = 1;
+  }
+
+  public int reserve() {
+    if (pq.size() == 0) {
+      return count++;
+    }
+    return pq.remove();
+  }
+
+  public void unreserve(int seatNumber) {
+    pq.add(seatNumber);
+  }
+}
+
+/**
+ * Your SeatManager object will be instantiated and called as such:
+ * SeatManager obj = new SeatManager(n);
+ * int param_1 = obj.reserve();
+ * obj.unreserve(seatNumber);
+ */

From 656c1a05cb1a4e64d89cfd7ecfaeb047e43ce7fd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 3 May 2021 09:49:24 -0700
Subject: [PATCH 0506/2175] Refactored Running Sum of 1d Array.java

---
 Easy/Running Sum of 1d Array.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Easy/Running Sum of 1d Array.java b/Easy/Running Sum of 1d Array.java
index 75f635ca..a724f9d9 100644
--- a/Easy/Running Sum of 1d Array.java	
+++ b/Easy/Running Sum of 1d Array.java	
@@ -1,10 +1,8 @@
 class Solution {
   public int[] runningSum(int[] nums) {
     int[] ans = new int[nums.length];
-    int sum = 0;
     for (int i = 0; i < nums.length; i++) {
-      sum += nums[i];
-      ans[i] = sum;
+      ans[i] = nums[i] + (i == 0 ? 0 : ans[i - 1]);
     }
     return ans;
   }

From e6261aab073a785d8838b92cb6dc65160b772bc8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 5 May 2021 10:38:13 -0700
Subject: [PATCH 0507/2175] Create Minimum Distance to the Target Element.java

---
 Easy/Minimum Distance to the Target Element.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Minimum Distance to the Target Element.java

diff --git a/Easy/Minimum Distance to the Target Element.java b/Easy/Minimum Distance to the Target Element.java
new file mode 100644
index 00000000..e182a20d
--- /dev/null
+++ b/Easy/Minimum Distance to the Target Element.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int getMinDistance(int[] nums, int target, int start) {
+    int minDistance = Integer.MAX_VALUE;
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] == target) {
+        minDistance = Math.min(minDistance, Math.abs(i - start));
+      }
+    }
+    return minDistance;
+  }
+}

From e521241325d04fd44052e91cdea4c2005dc31de6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 May 2021 08:38:03 -0700
Subject: [PATCH 0508/2175] Create Maximum Population Year.java

---
 Easy/Maximum Population Year.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Maximum Population Year.java

diff --git a/Easy/Maximum Population Year.java b/Easy/Maximum Population Year.java
new file mode 100644
index 00000000..93766873
--- /dev/null
+++ b/Easy/Maximum Population Year.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int maximumPopulation(int[][] logs) {
+    int[] population = new int[2051];
+    for (int[] log : logs) {
+      population[log[0]]++;
+      population[log[1]]--;
+    }
+    int maxPopulationYear = 0;
+    for (int i = 1950; i <= 2050; i++) {
+      population[i] += population[i - 1];
+      maxPopulationYear = population[i] > population[maxPopulationYear] ? i : maxPopulationYear;
+    }
+    return maxPopulationYear;
+  }
+}

From ffbad5638365ecf1941fe25b8c9c149fd804490b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 May 2021 19:28:43 -0700
Subject: [PATCH 0509/2175] Create Maximum Distance Between a Pair of
 Values.java

---
 ...mum Distance Between a Pair of Values.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Maximum Distance Between a Pair of Values.java

diff --git a/Medium/Maximum Distance Between a Pair of Values.java b/Medium/Maximum Distance Between a Pair of Values.java
new file mode 100644
index 00000000..f0388ec4
--- /dev/null
+++ b/Medium/Maximum Distance Between a Pair of Values.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public int maxDistance(int[] nums1, int[] nums2) {
+    int maxDistance = 0;
+    for (int i = 0; i < nums1.length; i++) {
+      int idx = getValidIdx(nums2, i, nums2.length - 1, nums1[i]);
+      if (idx != -1) {
+        maxDistance = Math.max(maxDistance, idx - i);
+      }
+    }
+    return maxDistance;
+  }
+  
+  private int getValidIdx(int[] nums, int start, int end, int limit) {
+    int idx = -1;
+    while (start <= end) {
+      int mid = (start + end) / 2;
+      if (nums[mid] >= limit) {
+        idx = Math.max(idx, mid);
+        start = mid + 1;
+      } else {
+        end = mid - 1;
+      }
+    }
+    return idx;
+  }
+}

From f4c30514daee7f036ce527f7f27d5223ee9d6917 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 10 May 2021 11:28:30 -0700
Subject: [PATCH 0510/2175] Update Count Primes.java

---
 Easy/Count Primes.java | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/Easy/Count Primes.java b/Easy/Count Primes.java
index 9b9347a0..4f1f9ec1 100644
--- a/Easy/Count Primes.java	
+++ b/Easy/Count Primes.java	
@@ -1,18 +1,21 @@
 class Solution {
   public int countPrimes(int n) {
-    boolean[] isPrime = new boolean[n];
-    Arrays.fill(isPrime, true);
-    for (int i = 2; i * i < n; i++) {
-      if (isPrime[i]) {
-        for (int j = i * i; j < n; j += i) {
-          isPrime[j] = false;
+    if (n < 2) {
+      return 0;
+    }
+    int[] nums = new int[n];
+    populateSieveArray(nums);
+    return (int) Arrays.stream(nums).boxed().filter(e -> e != -1).count();
+  }
+
+  private void populateSieveArray(int[] nums) {
+    Arrays.fill(nums, 0, 2, -1);
+    for (int i = 2; i < nums.length; i++) {
+      if (nums[i] != -1) {
+        for (int j = i + i; j < nums.length; j += i) {
+          nums[j] = -1;
         }
       }
     }
-    int numOfPrimes = 0;
-    for (int i = 2; i < n; i++) {
-      numOfPrimes += isPrime[i] ? 1 : 0;
-    }
-    return numOfPrimes;
   }
 }

From 2babe9b3e9ca1a33393764385e1dbf6ad33e3f15 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 15 May 2021 20:07:00 -0700
Subject: [PATCH 0511/2175] Create Sorting the Sentence.java

---
 Easy/Sorting the Sentence.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Sorting the Sentence.java

diff --git a/Easy/Sorting the Sentence.java b/Easy/Sorting the Sentence.java
new file mode 100644
index 00000000..94b78e3e
--- /dev/null
+++ b/Easy/Sorting the Sentence.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public String sortSentence(String s) {
+    String[] arr = new String[s.split(" ").length];
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      int currIdx = idx;
+      while (currIdx < n && Character.isLetter(s.charAt(currIdx))) {
+        currIdx++;
+      }
+      int wordIdx = Character.getNumericValue(s.charAt(currIdx++));
+      arr[wordIdx - 1] = s.substring(idx, currIdx - 1);
+      idx = currIdx + 1;
+    }
+    StringBuilder sb = new StringBuilder();
+    for (String word : arr) {
+      sb.append(word).append(" ");
+    }
+    return sb.toString().trim();
+  }
+}

From 4908c18a93f0251d939e4adeb55866e6698fa205 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 May 2021 09:12:00 -0700
Subject: [PATCH 0512/2175] Update Find Duplicate File in System.java

---
 Medium/Find Duplicate File in System.java | 25 +++++++++--------------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/Medium/Find Duplicate File in System.java b/Medium/Find Duplicate File in System.java
index 6570d540..d1ff2b4c 100644
--- a/Medium/Find Duplicate File in System.java	
+++ b/Medium/Find Duplicate File in System.java	
@@ -1,22 +1,17 @@
 class Solution {
   public List<List<String>> findDuplicate(String[] paths) {
-    Map<String, List<String>> map = new HashMap<>();
+    Map<String, Set<String>> map = new HashMap<>();
     for (String path : paths) {
-      String[] strs = path.split("\\s+");
-      String filePath = strs[0];
-      for (int i = 1; i < strs.length; i++) {
-        int startIdx = strs[i].indexOf('(');
-        String fileName = strs[i].substring(0, startIdx);
-        String content = strs[i].substring(startIdx, strs[i].length());
-        map.computeIfAbsent(content, k -> new ArrayList<>()).add(filePath + "/" + fileName);
+      String[] splitPath = path.split("\\s+");
+      String directory = splitPath[0];
+      for (int i = 1; i < splitPath.length; i++) {
+        String fileName = splitPath[i].substring(0, splitPath[i].indexOf('('));
+        String fileContent = splitPath[i]
+            .substring(splitPath[i].indexOf('(') + 1, splitPath[i].indexOf(')'));
+        map.computeIfAbsent(fileContent, k -> new HashSet<>()).add(directory + "/" + fileName);
       }
     }
-    List<List<String>> duplicateFiles = new ArrayList<>();
-    for (String key : map.keySet()) {
-      if (map.get(key).size() > 1) {
-        duplicateFiles.add(map.get(key));
-      } 
-    }
-    return duplicateFiles;
+    return map.values().stream().filter(entry -> entry.size() > 1).map(ArrayList::new)
+        .collect(Collectors.toList());
   }
 }

From fd43b15d6dfee78fd5e08cbac4bd13f6b98cf916 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 21 May 2021 08:25:34 -0700
Subject: [PATCH 0513/2175] Update Find and Replace Pattern.java

---
 Medium/Find and Replace Pattern.java | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/Medium/Find and Replace Pattern.java b/Medium/Find and Replace Pattern.java
index 8a54adbe..c3cd1593 100644
--- a/Medium/Find and Replace Pattern.java	
+++ b/Medium/Find and Replace Pattern.java	
@@ -1,21 +1,15 @@
 class Solution {
   public List<String> findAndReplacePattern(String[] words, String pattern) {
-    String patternCode = getCode(pattern);
-    List<String> list = new ArrayList<>();
-    for (String word : words) {
-      String wordCode = getCode(word);
-      if (wordCode.equals(patternCode)) {
-        list.add(word);
-      }
-    }
-    return list;
+    String patternString = getPattern(pattern);
+    return Arrays.stream(words).filter(e -> getPattern(e).equals(patternString))
+      .collect(Collectors.toList());
   }
   
-  private String getCode(String word) {
-    Map<Character, Integer> map = new HashMap<>();
+  private String getPattern(String s) {
     StringBuilder sb = new StringBuilder();
-    int count = 0;
-    for (char c : word.toCharArray()) {
+    Map<Character, Integer> map = new HashMap<>();
+    int count = 1;
+    for (char c : s.toCharArray()) {
       if (!map.containsKey(c)) {
         map.put(c, count++);
       }

From 39d9e0a3842c289d417da54587882e0b77967b45 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 May 2021 09:06:47 -0700
Subject: [PATCH 0514/2175] Create Incremental Memory Leak.java

---
 Medium/Incremental Memory Leak.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Incremental Memory Leak.java

diff --git a/Medium/Incremental Memory Leak.java b/Medium/Incremental Memory Leak.java
new file mode 100644
index 00000000..7db5de79
--- /dev/null
+++ b/Medium/Incremental Memory Leak.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int[] memLeak(int memory1, int memory2) {
+    int currentLeak = 1;
+    while (Math.max(memory1, memory2) >= currentLeak) {
+      if (memory1 >= memory2) {
+        memory1 -= currentLeak++;
+      } else {
+        memory2 -= currentLeak++;
+      }
+    }
+    return new int[]{currentLeak, memory1, memory2};
+  }
+}

From 292816e295e6312532a969ae727b11e540e8ae63 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 May 2021 06:16:56 -0700
Subject: [PATCH 0515/2175] Create Longer Contiguous Segments of Ones than
 Zeros.java

---
 ...ontiguous Segments of Ones than Zeros.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Longer Contiguous Segments of Ones than Zeros.java

diff --git a/Easy/Longer Contiguous Segments of Ones than Zeros.java b/Easy/Longer Contiguous Segments of Ones than Zeros.java
new file mode 100644
index 00000000..9a7d40c5
--- /dev/null
+++ b/Easy/Longer Contiguous Segments of Ones than Zeros.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public boolean checkZeroOnes(String s) {
+    int zeroBlock = 0;
+    int oneBlock = 0;
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      char c = s.charAt(idx);
+      int currCount = 0;
+      while (idx < n && s.charAt(idx) == c) {
+        currCount++;
+        idx++;
+      }
+      if (c == '0') {
+        zeroBlock = Math.max(zeroBlock, currCount);
+      } else {
+        oneBlock = Math.max(oneBlock, currCount);
+      }
+    }
+    return oneBlock > zeroBlock;
+  }
+}

From e0a28b2c259c0dfe2e4ae4a2a283bea92a0d05d6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 24 May 2021 08:26:14 -0700
Subject: [PATCH 0516/2175] Update To Lower Case.java

---
 Easy/To Lower Case.java | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/Easy/To Lower Case.java b/Easy/To Lower Case.java
index 623cb4d6..0640e6f0 100644
--- a/Easy/To Lower Case.java	
+++ b/Easy/To Lower Case.java	
@@ -1,15 +1,6 @@
 class Solution {
-  public String toLowerCase(String str) {
-    StringBuilder sb = new StringBuilder();
-    for (char c : str.toCharArray()) {
-      int ascii = (int) c;
-      if (c >= 65 && c <= 90) {
-        sb.append((char) (c - 65 + 97));
-      }
-      else {
-        sb.append(c);
-      }
-    }
-    return sb.toString();
+  public String toLowerCase(String s) {
+    return s.chars().mapToObj(c -> (char) c).map(Character::toLowerCase).map(String::valueOf)
+        .collect(Collectors.joining());
   }
 }

From bc1ddf96e5c15a1cbd450283941c91a75589a562 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 25 May 2021 08:18:18 -0700
Subject: [PATCH 0517/2175] Update Evaluate Reverse Polish Notation.java

---
 Medium/Evaluate Reverse Polish Notation.java | 50 +++++++++-----------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/Medium/Evaluate Reverse Polish Notation.java b/Medium/Evaluate Reverse Polish Notation.java
index 8b606b68..483049db 100644
--- a/Medium/Evaluate Reverse Polish Notation.java	
+++ b/Medium/Evaluate Reverse Polish Notation.java	
@@ -1,31 +1,27 @@
 class Solution {
-    public int evalRPN(String[] tokens) {
-        Stack<Integer> stack = new Stack<>();
-        Set<String> operations = new HashSet<>(Arrays.asList("-", "+", "*", "/"));
-        for (String token : tokens) {
-            if (operations.contains(token)) {
-                int num1 = stack.pop();
-                int num2 = stack.pop();
-                stack.push(performOperation(num2, num1, token));
-            }
-            else {
-                stack.push(Integer.parseInt(token));
-            }
-        }
-        
-        return stack.pop();
+  public int evalRPN(String[] tokens) {
+    Stack<Integer> stack = new Stack<>();
+    String operations = "+-/*";
+    for (String token : tokens) {
+      stack.push(operations.contains(token) ? Objects
+          .requireNonNull(performOperation(stack.pop(), stack.pop(), token))
+          : Integer.parseInt(token));
     }
-    
-    private int performOperation(int a, int b, String operation) {
-        switch(operation) {
-            case "+":
-                return a + b;
-            case "-":
-                return a - b;
-            case "*":
-                return a * b;
-            default:
-                return a / b;
-        }
+    return stack.pop();
+  }
+
+  private Integer performOperation(Integer secondOperand, Integer firstOperand, String operation) {
+    switch (operation) {
+      case "+":
+        return firstOperand + secondOperand;
+      case "-":
+        return firstOperand - secondOperand;
+      case "*":
+        return firstOperand * secondOperand;
+      case "/":
+        return firstOperand / secondOperand;
+      default:
+        return null;
     }
+  }
 }

From 40e677eb127f4694b8d5bb476ba99e4c0962e7be Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 29 May 2021 15:07:02 -0700
Subject: [PATCH 0518/2175] Create Substrings of Size Three with Distinct
 Characters.java

---
 ...f Size Three with Distinct Characters.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Substrings of Size Three with Distinct Characters.java

diff --git a/Easy/Substrings of Size Three with Distinct Characters.java b/Easy/Substrings of Size Three with Distinct Characters.java
new file mode 100644
index 00000000..9e54553f
--- /dev/null
+++ b/Easy/Substrings of Size Three with Distinct Characters.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int countGoodSubstrings(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    int count = 0;
+    for (int i = 0; i < Math.min(s.length(), 2); i++) {
+      map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
+    }
+    for (int i = 2; i < s.length(); i++) {
+      map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
+      if (map.size() == 3) {
+        count++;
+      }
+      map.put(s.charAt(i - 2), map.getOrDefault(s.charAt(i - 2), 0) - 1);
+      if (map.get(s.charAt(i - 2)) == 0) {
+        map.remove(s.charAt(i - 2));
+      }
+    }
+    return count;
+  }
+}

From f83ba4fd449a828a2048e921b87c8f7a34e2e12e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 31 May 2021 20:36:24 -0700
Subject: [PATCH 0519/2175] Create Check if Word Equals Summation of Two
 Words.java

---
 Check if Word Equals Summation of Two Words.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Check if Word Equals Summation of Two Words.java

diff --git a/Check if Word Equals Summation of Two Words.java b/Check if Word Equals Summation of Two Words.java
new file mode 100644
index 00000000..d7aa68ce
--- /dev/null
+++ b/Check if Word Equals Summation of Two Words.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public boolean isSumEqual(String firstWord, String secondWord, String targetWord) {
+    return getNumericalValue(firstWord) + getNumericalValue(secondWord) == getNumericalValue(targetWord);
+  }
+  
+  private int getNumericalValue(String s) {
+    int value = 0;
+    for (char c : s.toCharArray()) {
+      value = value * 10 + (c - 'a');
+    }
+    return value;
+  }
+}

From 8f4401671767d1314cd265a71e21500210424c3f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Jun 2021 07:42:11 -0700
Subject: [PATCH 0520/2175] Update Max Area of Island.java

---
 Easy/Max Area of Island.java | 50 ++++++++++++++++++++++++------------
 1 file changed, 34 insertions(+), 16 deletions(-)

diff --git a/Easy/Max Area of Island.java b/Easy/Max Area of Island.java
index cfd4e66c..d1b4c461 100644
--- a/Easy/Max Area of Island.java	
+++ b/Easy/Max Area of Island.java	
@@ -1,27 +1,45 @@
 class Solution {
-  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
+  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
   public int maxAreaOfIsland(int[][] grid) {
-    int m = grid.length;
-    int n = grid[0].length;
+    int rows = grid.length;
+    int cols = grid[0].length;
     int maxArea = 0;
-    boolean[][] visited = new boolean[m][n];
-    for (int i = 0; i < m; i++) {
-      for (int j = 0; j < n; j++) {
-        maxArea = Math.max(maxArea, helper(grid, i, j, m, n, visited));
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (grid[i][j] != 0) {
+          grid[i][j] = 0;
+          int currentArea = getArea(grid, i, j);
+          maxArea = Math.max(maxArea, currentArea);
+        }
       }
     }
     return maxArea;
   }
   
-  private int helper(int[][] grid, int i, int j, int m, int n, boolean[][] visited) {
-    if (i < 0 || i >= m || j < 0 || j >= n || visited[i][j] || grid[i][j] == 0) {
-      return 0;
-    }
-    int curr = 1;
-    visited[i][j] = true;
-    for (int[] dir : dirs) {
-      curr += helper(grid, i + dir[0], j + dir[1], m, n, visited);
+  private int getArea(int[][] grid, int i, int j) {
+    int currentArea = 0;
+    Queue<int[]> queue = new LinkedList<>();
+    queue.add(new int[]{i, j});
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int currX = removed[0];
+      int currY = removed[1];
+      currentArea++;
+      for (int[] dir : DIRS) {
+        int newX = dir[0] + currX;
+        int newY = dir[1] + currY;
+        if (isValidCoordinate(grid, newX, newY) && grid[newX][newY] == 1) {
+          queue.add(new int[]{newX, newY});
+          grid[newX][newY] = 0;
+        }
+      }
     }
-    return curr;
+    return currentArea;
+  }
+  
+  private boolean isValidCoordinate(int[][] grid, int i, int j) {
+    return i >= 0 && j >= 0 && i < grid.length && j < grid[0].length;
   }
 }

From c51b7511824496481d33d09062b1f5972e83c731 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Jun 2021 12:12:06 -0700
Subject: [PATCH 0521/2175] Create Maximum Value after Insertion.java

---
 Medium/Maximum Value after Insertion.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Maximum Value after Insertion.java

diff --git a/Medium/Maximum Value after Insertion.java b/Medium/Maximum Value after Insertion.java
new file mode 100644
index 00000000..78213f9b
--- /dev/null
+++ b/Medium/Maximum Value after Insertion.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public String maxValue(String n, int x) {
+    if (n.charAt(0) == '-') {
+      for (int i = 1; i < n.length(); i++) {
+        if (Character.getNumericValue(n.charAt(i)) > x) {
+          return "-" + n.substring(1, i) + x + n.substring(i);
+        }
+      }
+    } else {
+      for (int i = 0; i < n.length(); i++) {
+        if (Character.getNumericValue(n.charAt(i)) < x) {
+          return n.substring(0, i) + x + n.substring(i);
+        }
+      }
+    }
+    return n + x;
+  }
+}

From fdaa82a9eac43b08a43b7272768bb87e48b5ddcb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 3 Jun 2021 08:21:24 -0700
Subject: [PATCH 0522/2175] Added Minimize Maximum Pair Sum in Array.java

---
 Medium/Minimize Maximum Pair Sum in Array.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Minimize Maximum Pair Sum in Array.java

diff --git a/Medium/Minimize Maximum Pair Sum in Array.java b/Medium/Minimize Maximum Pair Sum in Array.java
new file mode 100644
index 00000000..4b555253
--- /dev/null
+++ b/Medium/Minimize Maximum Pair Sum in Array.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int minPairSum(int[] nums) {
+    Arrays.sort(nums);
+    int start = 0;
+    int end = nums.length - 1;
+    int maxPairSum = -1;
+    while (start < end) {
+      int currSum = nums[start++] + nums[end--];
+      maxPairSum = maxPairSum == -1 ? currSum : Math.max(maxPairSum, currSum);
+    }
+    return maxPairSum;
+  }
+}

From 1397da6203d356e5f7fc37f980d0fdaa138a96ec Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Jun 2021 08:47:55 -0700
Subject: [PATCH 0523/2175] Create Determine Whether Matrix Can Be Obtained By
 Rotation.java

---
 ...er Matrix Can Be Obtained By Rotation.java | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Easy/Determine Whether Matrix Can Be Obtained By Rotation.java

diff --git a/Easy/Determine Whether Matrix Can Be Obtained By Rotation.java b/Easy/Determine Whether Matrix Can Be Obtained By Rotation.java
new file mode 100644
index 00000000..7d1d6d46
--- /dev/null
+++ b/Easy/Determine Whether Matrix Can Be Obtained By Rotation.java	
@@ -0,0 +1,39 @@
+class Solution {
+  public boolean findRotation(int[][] mat, int[][] target) {
+    for (int i = 0; i < 4; i++) {
+      if (isEqual(mat, target)) {
+        return true;
+      }
+      rotate(mat);
+    }
+    return false;
+  }
+
+  private boolean isEqual(int[][] mat, int[][] target) {
+    for (int i = 0; i < mat.length; i++) {
+      for (int j = 0; j < mat[i].length; j++) {
+        if (mat[i][j] != target[i][j]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  private void rotate(int[][] mat){
+    for(int i = 0; i < mat.length; i++){
+      for(int j = i; j < mat[0].length; j++){
+        int temp = mat[i][j];
+        mat[i][j] = mat[j][i];
+        mat[j][i] = temp;
+      }
+    }
+    for(int i = 0; i < mat[0].length / 2; i++){
+      for(int j = 0; j < mat.length; j++){
+        int temp = mat[j][i];
+        mat[j][i] = mat[j][mat[0].length - i - 1];
+        mat[j][mat[0].length - i - 1] = temp;
+      }
+    }
+  }
+}

From 7cb5fe63160705b83603d08e836b1f217ee365d0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Jun 2021 09:53:44 -0700
Subject: [PATCH 0524/2175] Create Longest Consecutive Sequence  Solution.java

---
 Longest Consecutive Sequence  Solution.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Longest Consecutive Sequence  Solution.java

diff --git a/Longest Consecutive Sequence  Solution.java b/Longest Consecutive Sequence  Solution.java
new file mode 100644
index 00000000..0549b6e6
--- /dev/null
+++ b/Longest Consecutive Sequence  Solution.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int longestConsecutive(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int maxLength = 0;
+    for (int num : nums) {
+      if (map.containsKey(num)) {
+        continue;
+      }
+      int left = map.containsKey(num - 1) ? map.get(num - 1) : 0;
+      int right = map.containsKey(num + 1) ? map.get(num + 1) : 0;
+      int sum = left + right + 1;
+      maxLength = Math.max(maxLength, sum);
+      map.put(num, sum);
+      map.put(num - left, sum);
+      map.put(num + right, sum);
+    }
+    return maxLength;
+  }   
+}

From 0ca13d8358afc6cb9dbc4254d7825e7ad51a36fd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Jun 2021 12:16:31 -0700
Subject: [PATCH 0525/2175] Create Reduction Operations to Make the Array
 Elements Equal.java

---
 ...ions to Make the Array Elements Equal.java | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 Medium/Reduction Operations to Make the Array Elements Equal.java

diff --git a/Medium/Reduction Operations to Make the Array Elements Equal.java b/Medium/Reduction Operations to Make the Array Elements Equal.java
new file mode 100644
index 00000000..bb55c50e
--- /dev/null
+++ b/Medium/Reduction Operations to Make the Array Elements Equal.java	
@@ -0,0 +1,35 @@
+class Solution {
+  public int reductionOperations(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+      map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
+    }
+    PriorityQueue<KeyEntry> pq = new PriorityQueue<>(new Comparator<>(){
+      public int compare(KeyEntry k1, KeyEntry k2) {
+        return k2.key - k1.key;
+      }
+    });
+    for (Integer key : map.keySet()) {
+      pq.add(new KeyEntry(key, map.get(key)));
+    }
+    int numOfSteps = 0;
+    while (pq.size() > 1) {
+      KeyEntry largest = pq.poll();
+      KeyEntry secondLargest = pq.poll();
+      secondLargest.val += largest.val;
+      pq.add(secondLargest);
+      numOfSteps += largest.val;
+    }
+    return numOfSteps;
+  }
+}
+
+class KeyEntry {
+  int key;
+  int val;
+  
+  public KeyEntry(int key, int val) {
+    this.key = key;
+    this.val = val;
+  }
+}

From 9b9484bd6afe31ed478e1c41a48ed8b351cf0e27 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Jun 2021 09:20:51 -0700
Subject: [PATCH 0526/2175] Update My Calendar I.java

---
 Medium/My Calendar I.java | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/Medium/My Calendar I.java b/Medium/My Calendar I.java
index c225f6b2..17064e87 100644
--- a/Medium/My Calendar I.java	
+++ b/Medium/My Calendar I.java	
@@ -1,21 +1,21 @@
 class MyCalendar {
-    TreeMap<Integer, Integer> map;
-    
-    public MyCalendar() {
-        map = new TreeMap<>();
-    }
-    
-    public boolean book(int start, int end) {
-        Map.Entry<Integer, Integer> entry = map.lowerEntry(end);
-        if (entry != null && entry.getValue() > start) {
-            return false;
-        }
-        
-        map.put(start, end);
-        return true;
+
+  TreeMap<Integer, Integer> events;
+
+  public MyCalendar() {
+    events = new TreeMap<>();
+  }
+
+  public boolean book(int start, int end) {
+    Integer lower = events.floorKey(start);
+    Integer upper = events.ceilingKey(start);
+    if ((lower == null || events.get(lower) <= start) && (upper == null || end <= upper)) {
+      events.put(start, end);
+      return true;
     }
+    return false;
+  }
 }
-
 /**
  * Your MyCalendar object will be instantiated and called as such:
  * MyCalendar obj = new MyCalendar();

From 164d542159d54a3819eb5c2f993ef8c19bed3a29 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 12 Jun 2021 11:30:51 -0700
Subject: [PATCH 0527/2175] Added Check if All the Integers in a Range Are
 Covered.java

---
 ...if All the Integers in a Range Are Covered.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Check if All the Integers in a Range Are Covered.java

diff --git a/Easy/Check if All the Integers in a Range Are Covered.java b/Easy/Check if All the Integers in a Range Are Covered.java
new file mode 100644
index 00000000..63a5fd2d
--- /dev/null
+++ b/Easy/Check if All the Integers in a Range Are Covered.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public boolean isCovered(int[][] ranges, int left, int right) {
+    Arrays.sort(ranges, Comparator.comparingInt((int[] o) -> o[0]));
+    for (int[] range : ranges) {
+      if (left >= range[0] && left <= range[1]) {
+        left = range[1] + 1;
+      }
+      if (left > right) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

From 0f1352979a3def9b2332b728c1a811b00ee540fa Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 13 Jun 2021 06:51:39 -0700
Subject: [PATCH 0528/2175] Added Redistribute Characters to Make All Strings
 Equal.java

---
 ...istribute Characters to Make All Strings Equal.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Redistribute Characters to Make All Strings Equal.java

diff --git a/Easy/Redistribute Characters to Make All Strings Equal.java b/Easy/Redistribute Characters to Make All Strings Equal.java
new file mode 100644
index 00000000..e034cce7
--- /dev/null
+++ b/Easy/Redistribute Characters to Make All Strings Equal.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public boolean makeEqual(String[] words) {
+    return Arrays.stream(words)
+        .reduce((a, b) -> a + b).orElse("") // Merge all strings
+        .chars().mapToObj(c -> (char) c)
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting())) // Build a frequency map
+        .values().stream()
+        .allMatch(v -> v % words.length == 0); // Predicate logic to check frequency of each character
+  }
+}

From 0e27969729a54e38d9ec724266d88126a5c9a50e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 14 Jun 2021 08:05:19 -0700
Subject: [PATCH 0529/2175] Update Maximum Units on a Truck.java

---
 Easy/Maximum Units on a Truck.java | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Easy/Maximum Units on a Truck.java b/Easy/Maximum Units on a Truck.java
index da65b654..ce5198f0 100644
--- a/Easy/Maximum Units on a Truck.java	
+++ b/Easy/Maximum Units on a Truck.java	
@@ -1,20 +1,15 @@
 class Solution {
   public int maximumUnits(int[][] boxTypes, int truckSize) {
-    PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> {
-      int c = o2[1] - o1[1];
-      if (c != 0) {
-        return c;
+    Arrays.sort(boxTypes, (o1, o2) -> o2[1] - o1[1]);
+    int maxUnits = 0;
+    for (int[] boxType : boxTypes) {
+      if (truckSize == 0) {
+        break;
       }
-      return o2[0] - o1[0];
-    });
-    Collections.addAll(pq, boxTypes);
-    int maximumUnits = 0;
-    while (truckSize > 0 && !pq.isEmpty()) {
-      int[] boxType = pq.poll();
-      int boxesAdded = Math.min(boxType[0], truckSize);
-      maximumUnits += boxesAdded * boxType[1];
-      truckSize -= boxesAdded;
+      int numberOfBoxesLoaded = Math.min(truckSize, boxType[0]);
+      maxUnits += numberOfBoxesLoaded * boxType[1];
+      truckSize -= numberOfBoxesLoaded;
     }
-    return maximumUnits;
+    return maxUnits;
   }
 }

From cc86fefbf86ab38984d2635e0a332595b7e57d2f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 16 Jun 2021 21:45:08 -0700
Subject: [PATCH 0530/2175] Create Find the Student that Will Replace the
 Chalk.java

---
 ...the Student that Will Replace the Chalk.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Find the Student that Will Replace the Chalk.java

diff --git a/Medium/Find the Student that Will Replace the Chalk.java b/Medium/Find the Student that Will Replace the Chalk.java
new file mode 100644
index 00000000..8ee73065
--- /dev/null
+++ b/Medium/Find the Student that Will Replace the Chalk.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int chalkReplacer(int[] chalk, int k) {
+    int initialResult = chalkReplacerHelper(chalk, k);
+    return initialResult != -1 ? initialResult
+        : chalkReplacerHelper(chalk, k % Arrays.stream(chalk).sum());
+  }
+
+  private int chalkReplacerHelper(int[] chalk, int k) {
+    for (int i = 0; i < chalk.length; i++) {
+      if (k - chalk[i] < 0) {
+        return i;
+      }
+      k -= chalk[i];
+    }
+    return -1;
+  }
+}

From 6108f3f006d36a84a414bab07d959bf42e5c9d83 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 17 Jun 2021 07:50:40 -0700
Subject: [PATCH 0531/2175] Create Number of Subarrays with Bounded
 Maximum.java

---
 .../Number of Subarrays with Bounded Maximum.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Number of Subarrays with Bounded Maximum.java

diff --git a/Medium/Number of Subarrays with Bounded Maximum.java b/Medium/Number of Subarrays with Bounded Maximum.java
new file mode 100644
index 00000000..a8c71df3
--- /dev/null
+++ b/Medium/Number of Subarrays with Bounded Maximum.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int numSubarrayBoundedMax(int[] nums, int left, int right) {
+    return countHelper(nums, right) - countHelper(nums, left - 1);
+  } 
+  
+  private int countHelper(int[] nums, int bound) {
+    int count = 0;
+    int curr = 0;
+    for (int num : nums) {
+      curr = num <= bound ? curr + 1 : 0;
+      count += curr;
+    }
+    return count;
+  }
+}

From a499e5d88ab120bf728619aa9847afb7fcab7c12 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 19 Jun 2021 21:08:09 -0700
Subject: [PATCH 0532/2175] Create Largest Odd Number in String.java

---
 Easy/Largest Odd Number in String.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Largest Odd Number in String.java

diff --git a/Easy/Largest Odd Number in String.java b/Easy/Largest Odd Number in String.java
new file mode 100644
index 00000000..b43d4726
--- /dev/null
+++ b/Easy/Largest Odd Number in String.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public String largestOddNumber(String num) {
+    for (int i = num.length() - 1; i >= 0; i--) {
+      if (Character.getNumericValue(num.charAt(i)) % 2 != 0) {
+        return num.substring(0, i + 1);
+      }
+    }
+    return "";
+  }
+}

From 81a563b08772bc237a57ab3e1f7b957ad6d804ca Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Jun 2021 13:23:09 -0700
Subject: [PATCH 0533/2175] Create The Number of Full Rounds You Have
 Played.java

---
 ...Number of Full Rounds You Have Played.java | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/The Number of Full Rounds You Have Played.java

diff --git a/Medium/The Number of Full Rounds You Have Played.java b/Medium/The Number of Full Rounds You Have Played.java
new file mode 100644
index 00000000..a265d7f7
--- /dev/null
+++ b/Medium/The Number of Full Rounds You Have Played.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public int numberOfRounds(String startTime, String finishTime) {
+    int startMinutes = toMinutes(startTime);
+    int finishMinutes = toMinutes(finishTime);
+    int roundedStart = toNextQuarter(startMinutes);
+    int roundedFinish = toPreviousQuarter(finishMinutes);
+    if (startMinutes < finishMinutes) {
+      return Math.max(0, (roundedFinish - roundedStart) / 15);
+    }
+    return (24 * 60 - roundedStart + roundedFinish) / 15;
+  }
+
+  public static int toMinutes(String s) {
+    return Integer.parseInt(s.substring(0, 2)) * 60 + Integer.parseInt(s.substring(3, 5));
+  }
+
+  public static int toNextQuarter(int time) {
+    return ((time + 14) / 15) * 15;
+  }
+
+  public static int toPreviousQuarter(int time) {
+    return (time / 15) * 15;
+  }
+}

From 96c31eb2f7205f2aea067cc19736619ff1e46fda Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Jun 2021 17:57:55 -0700
Subject: [PATCH 0534/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c16f1700..cce3209c 100644
--- a/README.md
+++ b/README.md
@@ -2,5 +2,5 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 850+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 900+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)

From 9cf905c0d15fcfacada21c5fb782e0840967d238 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Jun 2021 06:18:57 -0700
Subject: [PATCH 0535/2175] Update Pascal's Triangle.java

---
 Easy/Pascal's Triangle.java | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/Easy/Pascal's Triangle.java b/Easy/Pascal's Triangle.java
index 5b3b7b8b..a64f8bd4 100644
--- a/Easy/Pascal's Triangle.java	
+++ b/Easy/Pascal's Triangle.java	
@@ -1,19 +1,15 @@
 class Solution {
   public List<List<Integer>> generate(int numRows) {
-    List<List<Integer>> ans = new ArrayList<>();
+    List<List<Integer>> result = new ArrayList<>();
     for (int i = 0; i < numRows; i++) {
-      List<Integer> list = new ArrayList<>();
-      for (int j = 0; j < i + 1; j++) {
-        if (j == 0 || j == i) {
-          list.add(1);
-        }
-        else {
-          list.add(ans.get(i - 1).get(j - 1) + ans.get(i - 1).get(j));
-        }
+      List<Integer> temp = new ArrayList<>();
+      for (int j = 0; j <= i; j++) {
+        temp.add(
+          (j == 0 || j == i) ? 1 : 
+          (result.get(i - 1).get(j - 1) + result.get(i - 1).get(j)));
       }
-      System.out.println(list);
-      ans.add(list);
+      result.add(temp);
     }
-    return ans;
+    return result;
   }
 }

From 33ea540e37f06deec04aff1f333c79817288733c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Jun 2021 06:12:33 -0700
Subject: [PATCH 0536/2175] Create Number of Matching Subsequences.java

---
 Medium/Number of Matching Subsequences.java | 23 +++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Number of Matching Subsequences.java

diff --git a/Medium/Number of Matching Subsequences.java b/Medium/Number of Matching Subsequences.java
new file mode 100644
index 00000000..8de23b10
--- /dev/null
+++ b/Medium/Number of Matching Subsequences.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int numMatchingSubseq(String s, String[] words) {
+    int count = 0;
+    for (String word : words) {
+      if (isSubsequence(s, word)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  private boolean isSubsequence(String s, String word) {
+    int prevIdx = 0;
+    for (char c : word.toCharArray()) {
+      int idx = s.indexOf(c, prevIdx);
+      if (idx == -1) {
+        return false;
+      }
+      prevIdx = idx + 1;
+    }
+    return true;
+  }
+}

From 779fc5f9d3a09160db4086a5a989c920d9e33eb9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Jun 2021 07:13:51 -0700
Subject: [PATCH 0537/2175] Create Maximum Product Difference Between Two
 Pairs.java

---
 Easy/Maximum Product Difference Between Two Pairs.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Easy/Maximum Product Difference Between Two Pairs.java

diff --git a/Easy/Maximum Product Difference Between Two Pairs.java b/Easy/Maximum Product Difference Between Two Pairs.java
new file mode 100644
index 00000000..3c3edf02
--- /dev/null
+++ b/Easy/Maximum Product Difference Between Two Pairs.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public int maxProductDifference(int[] nums) {
+    Arrays.sort(nums);
+    return nums[nums.length - 1] * nums[nums.length - 2] - nums[0] * nums[1];
+  }
+}

From c42f7ed469486d7256e5899cf15ca8100accff94 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Jun 2021 07:21:01 -0700
Subject: [PATCH 0538/2175] Create Remove One Element to Make the Array
 Strictly Increasing.java

---
 ...t to Make the Array Strictly Increasing.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Remove One Element to Make the Array Strictly Increasing.java

diff --git a/Easy/Remove One Element to Make the Array Strictly Increasing.java b/Easy/Remove One Element to Make the Array Strictly Increasing.java
new file mode 100644
index 00000000..74c4bf1d
--- /dev/null
+++ b/Easy/Remove One Element to Make the Array Strictly Increasing.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean canBeIncreasing(int[] nums) {
+    boolean removed = false;
+    for (int i = 1; i < nums.length; i++) {
+      if (nums[i] <= nums[i - 1]) {
+        if (removed) {
+          return false;
+        }
+        removed = true;
+        if (i > 1 && nums[i] <= nums[i - 2]) {
+          nums[i] = nums[i - 1];
+        }
+      }
+    }
+    return true;
+  }
+}

From c50fecfde7ad3e209f76457090747c64468d2ff6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Jun 2021 07:02:13 -0700
Subject: [PATCH 0539/2175] Create Remove All Occurrences of a Substring.java

---
 Medium/Remove All Occurrences of a Substring.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Remove All Occurrences of a Substring.java

diff --git a/Medium/Remove All Occurrences of a Substring.java b/Medium/Remove All Occurrences of a Substring.java
new file mode 100644
index 00000000..08fa1f78
--- /dev/null
+++ b/Medium/Remove All Occurrences of a Substring.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public String removeOccurrences(String s, String part) {
+    while (true) {
+      int idx = s.indexOf(part);
+      if (idx == -1) {
+        break;
+      }
+      s = s.substring(0, idx) + s.substring(idx + part.length());
+    }
+    return s;
+  }
+}

From f0769c9fb2c1da2fb60e1b588a6499f72e6c94b9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 2 Jul 2021 08:08:13 -0700
Subject: [PATCH 0540/2175] Update Find K Closest Elements.java

---
 Medium/Find K Closest Elements.java | 44 +++++------------------------
 1 file changed, 7 insertions(+), 37 deletions(-)

diff --git a/Medium/Find K Closest Elements.java b/Medium/Find K Closest Elements.java
index 76a292bb..2e49a608 100644
--- a/Medium/Find K Closest Elements.java	
+++ b/Medium/Find K Closest Elements.java	
@@ -1,41 +1,11 @@
 class Solution {
   public List<Integer> findClosestElements(int[] arr, int k, int x) {
-    if (k == 0 || arr.length == 0) {
-      return new ArrayList<>();
-    }
-    int[] diffArr = new int[arr.length];
-    int minDiff = Integer.MAX_VALUE;
-    int minDiffIdx = -1;
-    for (int i = 0; i < arr.length; i++) {
-      diffArr[i] = Math.abs(arr[i] - x);
-      if (minDiff > diffArr[i]) {
-        minDiff = diffArr[i];
-        minDiffIdx = i;
-      }
-    }
-    int left = minDiffIdx - 1;
-    int right = minDiffIdx + 1;
-    List<Integer> list = new ArrayList<>();
-    list.add(arr[minDiffIdx]);
-    k--;
-    while (k > 0) {
-      if (left >= 0 && right < arr.length) {
-        if (diffArr[left] <= diffArr[right]) {
-          list.add(arr[left--]);
-        }
-        else {
-          list.add(arr[right++]);
-        }
-      }
-      else if (left >= 0 && right == arr.length) {
-        list.add(arr[left--]);
-      }
-      else {
-        list.add(arr[right++]);
-      }
-      k--;
-    }
-    Collections.sort(list);
-    return list;
+     return Arrays.stream(arr)
+        .mapToObj(e -> new int[]{e, Math.abs(e - x)})
+        .sorted((o1, o2) -> (o1[1] - o2[1] != 0) ? (o1[1] - o2[1]) : o1[0] - o2[0])
+        .map(e -> e[0])
+        .limit(k)
+        .sorted()
+        .collect(Collectors.toList());
   }
 }

From 42361da903a2b5705a3d309845b28ecc34adde5e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Jul 2021 21:10:33 -0700
Subject: [PATCH 0541/2175] Create Build Array from Permutation.java

---
 Easy/Build Array from Permutation.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Build Array from Permutation.java

diff --git a/Easy/Build Array from Permutation.java b/Easy/Build Array from Permutation.java
new file mode 100644
index 00000000..88119f3d
--- /dev/null
+++ b/Easy/Build Array from Permutation.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public int[] buildArray(int[] nums) {
+    int[] ans = new int[nums.length];
+    for (int i = 0; i < nums.length; i++) {
+      ans[i] = nums[nums[i]];
+    }
+    return ans;
+  }
+}

From 73f28c6625723f0df6fefe91fc7ab9087ba589c4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 6 Jul 2021 08:15:15 -0700
Subject: [PATCH 0542/2175] Update Reduce Array Size to The Half.java

---
 Medium/Reduce Array Size to The Half.java | 30 +++++++++--------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/Medium/Reduce Array Size to The Half.java b/Medium/Reduce Array Size to The Half.java
index 50c84326..de698435 100644
--- a/Medium/Reduce Array Size to The Half.java	
+++ b/Medium/Reduce Array Size to The Half.java	
@@ -1,24 +1,16 @@
 class Solution {
   public int minSetSize(int[] arr) {
-    Map<Integer, Integer> map = new HashMap<>();
-    for (int num : arr) {
-      map.put(num, map.getOrDefault(num, 0) + 1);
+    Map<Integer, Long> frequencyMap = Arrays.stream(arr).boxed()
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
+    int halfSize = arr.length / 2;
+    PriorityQueue<Integer> pq = new PriorityQueue<>(
+        (o1, o2) -> (int) (frequencyMap.get(o2) - frequencyMap.get(o1)));
+    pq.addAll(frequencyMap.keySet());
+    int counter = 0;
+    while (!pq.isEmpty() && halfSize > 0) {
+      halfSize -= frequencyMap.get(pq.poll());
+      counter++;
     }
-    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
-      public int compare(Integer o1, Integer o2) {
-        return map.get(o2) - map.get(o1);
-      }
-    });
-    for (Integer key : map.keySet()) {
-      pq.add(key);
-    }
-    int n = arr.length / 2;
-    int currSize = 0;
-    int count = 0;
-    while (currSize < n) {
-      currSize += map.get(pq.poll());
-      count++;
-    }
-    return count;
+    return counter;
   }
 }

From ee0c89b8307cd2b77a20fea880c852a31bdb950f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 10 Jul 2021 10:33:19 -0700
Subject: [PATCH 0543/2175] Create Count Square Sum Triples.java

---
 Easy/Count Square Sum Triples.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Count Square Sum Triples.java

diff --git a/Easy/Count Square Sum Triples.java b/Easy/Count Square Sum Triples.java
new file mode 100644
index 00000000..a7c47e94
--- /dev/null
+++ b/Easy/Count Square Sum Triples.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int countTriples(int n) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 1; i <= n; i++) {
+      map.put(i*i, i);
+    }
+    int count = 0;
+    for (int i = 1; i <= n; i++) {
+      for (int j = i + 1; j <= n; j++) {
+        int key = i * i + j * j;
+        if (map.containsKey(key) && !map.get(key).equals(i) && !map.get(key).equals(j)) {
+          count += 2;
+        }
+      }
+    }
+    return count;
+  }
+}

From 921a7e880840a4856869bdbdba127d380eca84eb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Jul 2021 07:33:41 -0700
Subject: [PATCH 0544/2175] Create Concatenation of Array.java

---
 Easy/Concatenation of Array.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Concatenation of Array.java

diff --git a/Easy/Concatenation of Array.java b/Easy/Concatenation of Array.java
new file mode 100644
index 00000000..f4042c0b
--- /dev/null
+++ b/Easy/Concatenation of Array.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public int[] getConcatenation(int[] nums) {
+    int[] ans = new int[nums.length * 2];
+    for (int i = 0; i < nums.length; i++) {
+      ans[i + nums.length] = ans[i] = nums[i];
+    }
+    return ans;
+  }
+}

From 9199efa579d31d39f0918c27770c7d47fc749c92 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 17 Jul 2021 21:06:25 -0700
Subject: [PATCH 0545/2175] Create Maximum Number of Words You Can Type.java

---
 Easy/Maximum Number of Words You Can Type.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Maximum Number of Words You Can Type.java

diff --git a/Easy/Maximum Number of Words You Can Type.java b/Easy/Maximum Number of Words You Can Type.java
new file mode 100644
index 00000000..dd3afc70
--- /dev/null
+++ b/Easy/Maximum Number of Words You Can Type.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public int canBeTypedWords(String text, String brokenLetters) {
+    return (int) Arrays.stream(text.split("\\s+"))
+        .filter(e -> e.chars()
+            .mapToObj(c -> (char) c)
+            .noneMatch(c -> brokenLetters.indexOf(c) != -1))
+        .count();
+  }
+}

From 0b179f2d1747da1a28e4da7bd59a4df852d90862 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Jul 2021 17:14:41 -0700
Subject: [PATCH 0546/2175] Create Add Minimum Number of Rungs.java

---
 Medium/Add Minimum Number of Rungs.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Add Minimum Number of Rungs.java

diff --git a/Medium/Add Minimum Number of Rungs.java b/Medium/Add Minimum Number of Rungs.java
new file mode 100644
index 00000000..f473ea61
--- /dev/null
+++ b/Medium/Add Minimum Number of Rungs.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int addRungs(int[] rungs, int dist) {
+    int numOfRungs = 0;
+    int currPos = 0;
+    for (int rung : rungs) {
+      numOfRungs += (rung - currPos - 1) / dist;
+      currPos = rung;
+    }
+    return numOfRungs;
+  }
+}

From e4e589d3ee5fe2686c79c0db5490f92bb4e9d8ce Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 19 Jul 2021 07:56:44 -0700
Subject: [PATCH 0547/2175] Update Lowest Common Ancestor of a Binary Search
 Tree.java

---
 ...mmon Ancestor of a Binary Search Tree.java | 20 +++++++------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/Easy/Lowest Common Ancestor of a Binary Search Tree.java b/Easy/Lowest Common Ancestor of a Binary Search Tree.java
index aba618f7..c4092475 100644
--- a/Easy/Lowest Common Ancestor of a Binary Search Tree.java	
+++ b/Easy/Lowest Common Ancestor of a Binary Search Tree.java	
@@ -7,22 +7,16 @@
  *     TreeNode(int x) { val = x; }
  * }
  */
+
 class Solution {
   public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null || p == null || q == null) {
-      return null;
-    }
-    if (root == p || root == q) {
-      return root;
-    }
-    if ((root.val > p.val && root.val < q.val) || (root.val < p.val && root.val > q.val)) {
+    if (root == p || root == q || 
+        (p.val > root.val && q.val < root.val) || 
+        (p.val < root.val && q.val > root.val)) {
       return root;
     }
-    if (root.val > p.val && root.val > q.val) {
-      return lowestCommonAncestor(root.left, p, q);
-    }
-    else {
-      return lowestCommonAncestor(root.right, p, q);
-    }
+    return ((root.val > p.val && root.val > q.val) ? 
+            lowestCommonAncestor(root.left, p, q) : 
+            lowestCommonAncestor(root.right, p, q));
   }
 }

From 658cc1761191e69d3aa93ada0aeffe69140a472e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Jul 2021 11:18:20 -0700
Subject: [PATCH 0548/2175] Create Check if All Characters Have Equal Number of
 Occurrences.java

---
 ...if All Characters Have Equal Number of Occurrences.java | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Easy/Check if All Characters Have Equal Number of Occurrences.java

diff --git a/Easy/Check if All Characters Have Equal Number of Occurrences.java b/Easy/Check if All Characters Have Equal Number of Occurrences.java
new file mode 100644
index 00000000..1de5d301
--- /dev/null
+++ b/Easy/Check if All Characters Have Equal Number of Occurrences.java	
@@ -0,0 +1,7 @@
+class Solution {
+  public boolean areOccurrencesEqual(String s) {
+    return new HashSet<>(s.chars().mapToObj(c -> (char) c)
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()))
+        .values()).size() == 1;
+  }
+}

From d876bcae57926e079bc1dc5df8de3fc79d5730d3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Jul 2021 22:30:24 -0700
Subject: [PATCH 0549/2175] Create Sum of Digits of String After Convert.java

---
 Easy/Sum of Digits of String After Convert.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Sum of Digits of String After Convert.java

diff --git a/Easy/Sum of Digits of String After Convert.java b/Easy/Sum of Digits of String After Convert.java
new file mode 100644
index 00000000..c86c724c
--- /dev/null
+++ b/Easy/Sum of Digits of String After Convert.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int getLucky(String s, int k) {
+    StringBuilder sb = new StringBuilder();
+    for (char c : s.toCharArray()) {
+      sb.append(c - 'a' + 1);
+    }
+    String num = sb.toString();
+    while (k-- > 0) {
+      int sum = 0;
+      for (char c : num.toCharArray()) {
+        sum += Character.getNumericValue(c);
+      }
+      num = String.valueOf(sum);
+    }
+    return Integer.parseInt(num);
+  }
+}

From 6cda825a9aa31bc28ca919a49c68bb397f974564 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 1 Aug 2021 11:24:31 -0700
Subject: [PATCH 0550/2175] Create Three Divisors.java

---
 Easy/Three Divisors.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Three Divisors.java

diff --git a/Easy/Three Divisors.java b/Easy/Three Divisors.java
new file mode 100644
index 00000000..7b755498
--- /dev/null
+++ b/Easy/Three Divisors.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public boolean isThree(int n) {
+    int numOfDivisors = 0;
+    for (int i = 1; i <= n; i++) {
+      if (n % i == 0) {
+        numOfDivisors++;
+      }
+      if (numOfDivisors > 3) {
+        return false;
+      }
+    }
+    return numOfDivisors == 3;
+  }
+}

From f2b9fe1ab4d2a1df8a3ea8179ca5aa3f4d17f530 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Aug 2021 06:16:27 -0700
Subject: [PATCH 0551/2175] Update Path Sum II.java

---
 Medium/Path Sum II.java | 52 ++++++++++++++++++++---------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/Medium/Path Sum II.java b/Medium/Path Sum II.java
index e90b2004..c9610a27 100644
--- a/Medium/Path Sum II.java	
+++ b/Medium/Path Sum II.java	
@@ -4,36 +4,36 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
+  public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
     List<List<Integer>> list = new ArrayList<>();
-    public List<List<Integer>> pathSum(TreeNode root, int sum) {
-        if (root == null) return list;
-        
-        Stack<Integer> path = new Stack<>();
-        
-        pathSumImpl(root, sum, path);
-        return list;
+    helper(root, targetSum, new ArrayList<>(), list);
+    return list;
+  }
+  
+  private void helper(TreeNode root, int targetSum, List<Integer> curr, List<List<Integer>> list) {
+    if (root == null) {
+      return;
     }
-    
-    private void pathSumImpl(TreeNode root, int sum, Stack<Integer> path) {
-        path.push(root.val);
-        if (root.left == null && root.right == null) {
-            if (sum == root.val) {
-                list.add(new ArrayList<Integer>(path));
-            }
-        }
-        
-        if (root.left != null) {
-            pathSumImpl(root.left, sum-root.val, path);
-        }
-        
-        if (root.right != null) {
-            pathSumImpl(root.right, sum-root.val, path);
-        }
-        
-        path.pop();
+    curr.add(root.val);
+    if (isLeaf(root) && (targetSum - root.val) == 0) {
+      list.add(new ArrayList<>(curr));
     }
+    helper(root.left, targetSum - root.val, curr, list);
+    helper(root.right, targetSum - root.val, curr, list);
+    curr.remove(curr.size() - 1);
+  }
+  
+  private boolean isLeaf(TreeNode root) {
+    return root.left == null && root.right == null;
+  }
 }

From b85830e7e6dd72c3db893efe779d865932634172 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 7 Aug 2021 09:09:07 -0700
Subject: [PATCH 0552/2175] Create Delete Characters to Make Fancy String.java

---
 ...Delete Characters to Make Fancy String.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Delete Characters to Make Fancy String.java

diff --git a/Easy/Delete Characters to Make Fancy String.java b/Easy/Delete Characters to Make Fancy String.java
new file mode 100644
index 00000000..ff26a1b4
--- /dev/null
+++ b/Easy/Delete Characters to Make Fancy String.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public String makeFancyString(String s) {
+    int idx = 0;
+    StringBuilder sb = new StringBuilder();
+    while (idx < s.length()) {
+      char c = s.charAt(idx);
+      int count = 0;
+      while (idx < s.length() && s.charAt(idx) == c) {
+        idx++;
+        count++;
+        if (count <= 2) {
+          sb.append(c);
+        }
+      }
+    }
+    return sb.toString();
+  }
+}

From fc76913c17cb3dfe845b28c4f6152a4a854d9de9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Aug 2021 07:06:34 -0700
Subject: [PATCH 0553/2175] Create Check If String Is a Prefix of Array.java

---
 Easy/Check If String Is a Prefix of Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Check If String Is a Prefix of Array.java

diff --git a/Easy/Check If String Is a Prefix of Array.java b/Easy/Check If String Is a Prefix of Array.java
new file mode 100644
index 00000000..faf8f894
--- /dev/null
+++ b/Easy/Check If String Is a Prefix of Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean isPrefixString(String s, String[] words) {
+    int idx = 0;
+    for (String word : words) {
+      for (int i = 0; i < word.length(); i++) {
+        if (word.charAt(i) != s.charAt(idx)) {
+          return false;
+        }
+        idx++;
+        if (idx == s.length()) {
+          return i == word.length() - 1;
+        }
+      }
+    }
+    return idx == s.length();
+  }   
+}

From 0f9be0005f4ae3cf91a8dca78c0f745d3fba5ddf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 9 Aug 2021 07:55:03 -0700
Subject: [PATCH 0554/2175] Update Add Strings.java

---
 Easy/Add Strings.java | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Easy/Add Strings.java b/Easy/Add Strings.java
index f229760b..6a68a142 100644
--- a/Easy/Add Strings.java	
+++ b/Easy/Add Strings.java	
@@ -1,27 +1,22 @@
 class Solution {
   public String addStrings(String num1, String num2) {
     StringBuilder sb = new StringBuilder();
-    int idx1 = num1.length() - 1;
-    int idx2 = num2.length() - 1;
+    int idxOne = num1.length() - 1;
+    int idxTwo = num2.length() - 1;
     int carry = 0;
-    while (idx1 >= 0 || idx2 >= 0) {
+    while (idxOne >= 0 || idxTwo >= 0 || carry > 0) {
       int temp = carry;
-      if (idx1 >= 0 && idx2 >= 0) {
-        temp += Character.getNumericValue(num1.charAt(idx1--)) + Character.getNumericValue(num2.charAt(idx2--));
-      }
-      else if (idx1 >= 0 && idx2 < 0) {
-        temp += Character.getNumericValue(num1.charAt(idx1--));
-      }
-      else {
-        temp += Character.getNumericValue(num2.charAt(idx2--));
+      if (idxOne >= 0 && idxTwo >= 0) {
+        temp += Character.getNumericValue(num1.charAt(idxOne--)) + Character.getNumericValue(num2.charAt(idxTwo--));
+      } else if (idxOne >= 0 && idxTwo < 0) {
+        temp += Character.getNumericValue(num1.charAt(idxOne--));
+      } else if (idxOne < 0 && idxTwo >= 0) {
+        temp += Character.getNumericValue(num2.charAt(idxTwo--));
       }
       carry = temp > 9 ? 1 : 0;
       temp = temp > 9 ? temp % 10 : temp;
       sb.append(temp);
     }
-    if (carry > 0) {
-      sb.append(carry);
-    }
     return sb.reverse().toString();
   }
 }

From 777984a1498cfb630cc04ce13a42ac61dd54ccbd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 12 Aug 2021 15:46:23 -0700
Subject: [PATCH 0555/2175] Update Group Anagrams.java

---
 Medium/Group Anagrams.java | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Medium/Group Anagrams.java b/Medium/Group Anagrams.java
index 3ce07c65..deca920f 100644
--- a/Medium/Group Anagrams.java	
+++ b/Medium/Group Anagrams.java	
@@ -1,19 +1,14 @@
 class Solution {
   public List<List<String>> groupAnagrams(String[] strs) {
-    Map<String, List<String>> map = new HashMap<>();
-    for (String str : strs) {
-      String key = getKey(str);
-      map.computeIfAbsent(key, k -> new ArrayList<>()).add(str);
-    }
-    List<List<String>> ans = new ArrayList<>(map.values());
-    return ans;
+    return new ArrayList<>(
+        Arrays.stream(strs).collect(Collectors.groupingBy(Solution::getCodedString)).values());
   }
-  
-  private String getKey(String s) {
-    int[] counter = new int[26];
-    for (char c : s.toCharArray()) {
-      counter[c - 'a']++;
-    }
-    return Arrays.toString(counter);
+
+  public static String getCodedString(String s) {
+    return s.chars()
+        .mapToObj(c -> (char) c)
+        .sorted()
+        .map(Object::toString)
+        .collect(Collectors.joining());
   }
 }

From fa6d3b87848206db389c8b263c7c4caed5bd0dd6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 15 Aug 2021 20:09:48 -0700
Subject: [PATCH 0556/2175] Create Number of Strings That Appear as Substrings
 in Word.java

---
 .../Number of Strings That Appear as Substrings in Word.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Number of Strings That Appear as Substrings in Word.java

diff --git a/Easy/Number of Strings That Appear as Substrings in Word.java b/Easy/Number of Strings That Appear as Substrings in Word.java
new file mode 100644
index 00000000..f328158d
--- /dev/null
+++ b/Easy/Number of Strings That Appear as Substrings in Word.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public int numOfStrings(String[] patterns, String word) {
+    return (int) Arrays.stream(patterns).filter(p -> word.contains(p)).count();
+  }
+}

From 0256a21d84da4835f60318090e4ad11b0ff731f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 16 Aug 2021 08:12:53 -0700
Subject: [PATCH 0557/2175] Update and rename Range Sum Query_Immutable.java to
 Range Sum Query Immutable.java

---
 Easy/Range Sum Query Immutable.java | 23 +++++++++++++++++++++++
 Easy/Range Sum Query_Immutable.java | 26 --------------------------
 2 files changed, 23 insertions(+), 26 deletions(-)
 create mode 100644 Easy/Range Sum Query Immutable.java
 delete mode 100644 Easy/Range Sum Query_Immutable.java

diff --git a/Easy/Range Sum Query Immutable.java b/Easy/Range Sum Query Immutable.java
new file mode 100644
index 00000000..5318818c
--- /dev/null
+++ b/Easy/Range Sum Query Immutable.java	
@@ -0,0 +1,23 @@
+class NumArray {
+
+  int[] sumArray;
+  
+  public NumArray(int[] nums) {
+    sumArray = new int[nums.length];
+    int currSum = 0;
+    for (int i = 0; i < nums.length; i++) {
+      currSum += nums[i];
+      sumArray[i] = currSum;
+    }
+  }
+
+  public int sumRange(int left, int right) {
+    return sumArray[right] - (left == 0 ? 0 : sumArray[left - 1]);
+  }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * int param_1 = obj.sumRange(left,right);
+ */
diff --git a/Easy/Range Sum Query_Immutable.java b/Easy/Range Sum Query_Immutable.java
deleted file mode 100644
index 9a5b7fc8..00000000
--- a/Easy/Range Sum Query_Immutable.java	
+++ /dev/null
@@ -1,26 +0,0 @@
-class NumArray {
-  int[] cumulativeSum;
-  int n;
-  public NumArray(int[] nums) {
-    n = nums.length;
-    cumulativeSum = new int[n];
-    int currSum = 0;
-    for (int i = 0; i < n; i++) {
-      currSum += nums[i];
-      cumulativeSum[i] = currSum;
-    }
-  }
-
-  public int sumRange(int i, int j) {
-    if (i == 0) {
-      return cumulativeSum[j];
-    }
-    return cumulativeSum[j] - cumulativeSum[i - 1];
-  }
-}
-
-/**
- * Your NumArray object will be instantiated and called as such:
- * NumArray obj = new NumArray(nums);
- * int param_1 = obj.sumRange(i,j);
- */

From 95c5bf345d83ad1640e4f4a3175c6946eb1ba2a5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 16 Aug 2021 16:10:48 -0700
Subject: [PATCH 0558/2175] Update Minimum Window Substring.java

---
 Hard/Minimum Window Substring.java | 71 ++++++++++++++----------------
 1 file changed, 33 insertions(+), 38 deletions(-)

diff --git a/Hard/Minimum Window Substring.java b/Hard/Minimum Window Substring.java
index b5d6ae76..2e8bb271 100644
--- a/Hard/Minimum Window Substring.java	
+++ b/Hard/Minimum Window Substring.java	
@@ -1,43 +1,38 @@
 class Solution {
-    public String minWindow(String s, String t) {
-        Map<Character, Integer> map = new HashMap<>();
-        for (char c : t.toCharArray()) {
-            map.put(c, (map.getOrDefault(c, 0) + 1));
+  public String minWindow(String s, String t) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (char c : t.toCharArray()) {
+      map.put(c, map.getOrDefault(c, 0) + 1);
+    }
+    int count = map.size();
+    int start = 0;
+    int end = 0;
+    int minWindowLength = Integer.MAX_VALUE;
+    int minWindowStart = 0;
+    int minWindowEnd = 0;
+    while (end < s.length()) {
+      char c = s.charAt(end++);
+      if (map.containsKey(c)) {
+        map.put(c, map.get(c) - 1);
+        if (map.get(c) == 0) {
+          count--;
+        }
+      }
+      while (count == 0 && start < end) {
+        if (end - start < minWindowLength) {
+          minWindowLength = end - start;
+          minWindowStart = start;
+          minWindowEnd = end;
         }
-
-        int start = 0;
-        int end = 0;
-        int count = map.size();
-        int minLen = Integer.MAX_VALUE;
-        String ans = "";
-
-        while (end < s.length()) {
-            if (map.containsKey(s.charAt(end))) {
-                map.put(s.charAt(end), map.get(s.charAt(end)) - 1);
-                if (map.get(s.charAt(end)) == 0) {
-                    count--;
-                }
-            }
-
-            end++;
-
-            while (count == 0) {
-                if (end - start < minLen) {
-                    minLen = end - start;
-                    ans = s.substring(start, end);
-                }
-
-                if (map.containsKey(s.charAt(start))) {
-                    map.put(s.charAt(start), map.get(s.charAt(start)) + 1);
-                    if (map.get(s.charAt(start)) > 0) {
-                        count++;
-                    }
-                }
-
-                start++;
-            }
+        char temp = s.charAt(start++);
+        if (map.containsKey(temp)) {
+          map.put(temp, map.get(temp) + 1);
+          if (map.get(temp) == 1) {
+            count++;
+          }
         }
-
-        return ans;
+      }
     }
+    return s.substring(minWindowStart, minWindowEnd);
+  }
 }

From 259ec48a0fe94034d8e2835dc01f0909e8f9f610 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 17 Aug 2021 08:23:17 -0700
Subject: [PATCH 0559/2175] Added both recursive and non-recursive
 implementation

---
 Medium/Count Good Nodes in Binary Tree.java | 40 ++++++++++++++++++---
 1 file changed, 36 insertions(+), 4 deletions(-)

diff --git a/Medium/Count Good Nodes in Binary Tree.java b/Medium/Count Good Nodes in Binary Tree.java
index e5f87685..d3888f9d 100644
--- a/Medium/Count Good Nodes in Binary Tree.java	
+++ b/Medium/Count Good Nodes in Binary Tree.java	
@@ -16,18 +16,50 @@
 class Solution {
   public int goodNodes(TreeNode root) {
     int[] count = {0};
-    helper(root, root.val, count);
+    getGoodNodesCountRecursive(root, Integer.MIN_VALUE, count);
     return count[0];
   }
   
-  private void helper(TreeNode root, int currMax, int[] count) {
+  private void getGoodNodesCountRecursive(TreeNode root, int currMax, int[] count) {
     if (root == null) {
       return;
     }
     if (root.val >= currMax) {
       count[0]++;
     }
-    helper(root.left, Math.max(currMax, root.val), count);
-    helper(root.right, Math.max(currMax, root.val), count);
+    getGoodNodesCountRecursive(root.left, Math.max(currMax, root.val), count);
+    getGoodNodesCountRecursive(root.right, Math.max(currMax, root.val), count);
+  }
+  
+  private int getGoodNodesCountNonRecursive(TreeNode root) {
+    if (root == null) {
+      return 0;
+    }
+    int count = 0;
+    Queue<TreePair> queue = new LinkedList<>();
+    queue.add(new TreePair(root, Integer.MIN_VALUE));
+    while (!queue.isEmpty()) {
+      TreePair removed = queue.remove();
+      if (removed.node.val >= removed.currMax) {
+        count++;
+      }
+      if (removed.node.left != null) {
+        queue.add(new TreePair(removed.node.left, Math.max(removed.node.val, removed.currMax)));
+      }
+      if (removed.node.right != null) {
+        queue.add(new TreePair(removed.node.right, Math.max(removed.node.val, removed.currMax)));
+      }
+    }
+    return count;
+  }
+  
+  class TreePair {
+    int currMax;
+    TreeNode node;
+
+    public TreePair(TreeNode node, int currMax) {
+      this.currMax = currMax;
+      this.node = node;
+    }
   }
 }

From 1c827db68938bacd13f3fc1774a20515746bbbd5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 21 Aug 2021 09:39:05 -0700
Subject: [PATCH 0560/2175] Create Minimum Time to Type Word Using Special
 Typewriter.java

---
 ...m Time to Type Word Using Special Typewriter.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Minimum Time to Type Word Using Special Typewriter.java

diff --git a/Easy/Minimum Time to Type Word Using Special Typewriter.java b/Easy/Minimum Time to Type Word Using Special Typewriter.java
new file mode 100644
index 00000000..e804f716
--- /dev/null
+++ b/Easy/Minimum Time to Type Word Using Special Typewriter.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int minTimeToType(String word) {
+    int totalTime = 0;
+    char currentChar = 'a';
+    for (char c : word.toCharArray()) {
+      int difference = Math.abs(c - currentChar);
+      totalTime += 1 + Math.min(difference, 26 - difference);
+      currentChar = c;
+    }
+    return totalTime;
+  }
+}

From c685fc70d3af1b0c40038ad46e6e2b107d230fee Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 Aug 2021 07:21:11 -0700
Subject: [PATCH 0561/2175] Update Complex Number Multiplication.java

---
 Medium/Complex Number Multiplication.java | 22 ++++++----------------
 1 file changed, 6 insertions(+), 16 deletions(-)

diff --git a/Medium/Complex Number Multiplication.java b/Medium/Complex Number Multiplication.java
index c206de72..bb24eb73 100644
--- a/Medium/Complex Number Multiplication.java	
+++ b/Medium/Complex Number Multiplication.java	
@@ -1,19 +1,9 @@
 class Solution {
-  public String complexNumberMultiply(String a, String b) {
-    int realPart = 0;
-    int complexPart = 0;
-    int[] splitA = helper(a);
-    int[] splitB = helper(b);
-    realPart = splitA[0] * splitB[0] - splitA[1] * splitB[1];
-    complexPart = splitA[0] * splitB[1] + splitA[1] * splitB[0];
-    return realPart + "+" + complexPart + "i";
-  }
-  
-  private int[] helper(String s) {
-    String[] strs = s.split("\\+");
-    int[] arr = new int[2];
-    arr[0] = Integer.parseInt(strs[0]);
-    arr[1] = Integer.parseInt(strs[1].substring(0, strs[1].indexOf('i')));
-    return arr;
+  public String complexNumberMultiply(String num1, String num2) {
+    int realPartOne = Integer.parseInt(num1.split("\\+")[0]);
+    int imaginaryPartOne = Integer.parseInt(num1.split("\\+")[1].substring(0, num1.split("\\+")[1].length() - 1));
+    int realPartTwo = Integer.parseInt(num2.split("\\+")[0]);
+        int imaginaryPartTwo = Integer.parseInt(num2.split("\\+")[1].substring(0, num2.split("\\+")[1].length() - 1));
+    return (realPartOne * realPartTwo - imaginaryPartOne * imaginaryPartTwo) + "+" + (realPartOne * imaginaryPartTwo + realPartTwo * imaginaryPartOne) + "i";
   }
 }

From 5397a2e48952f50cd0022f54465783dcfd924426 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 Aug 2021 07:21:21 -0700
Subject: [PATCH 0562/2175] Update Complex Number Multiplication.java

---
 Medium/Complex Number Multiplication.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Medium/Complex Number Multiplication.java b/Medium/Complex Number Multiplication.java
index bb24eb73..0eb7dd43 100644
--- a/Medium/Complex Number Multiplication.java	
+++ b/Medium/Complex Number Multiplication.java	
@@ -3,7 +3,7 @@ public String complexNumberMultiply(String num1, String num2) {
     int realPartOne = Integer.parseInt(num1.split("\\+")[0]);
     int imaginaryPartOne = Integer.parseInt(num1.split("\\+")[1].substring(0, num1.split("\\+")[1].length() - 1));
     int realPartTwo = Integer.parseInt(num2.split("\\+")[0]);
-        int imaginaryPartTwo = Integer.parseInt(num2.split("\\+")[1].substring(0, num2.split("\\+")[1].length() - 1));
+    int imaginaryPartTwo = Integer.parseInt(num2.split("\\+")[1].substring(0, num2.split("\\+")[1].length() - 1));
     return (realPartOne * realPartTwo - imaginaryPartOne * imaginaryPartTwo) + "+" + (realPartOne * imaginaryPartTwo + realPartTwo * imaginaryPartOne) + "i";
   }
 }

From 5468fa22071388af705c3fdc488b55980b1cbf88 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 Aug 2021 20:31:54 -0700
Subject: [PATCH 0563/2175] Create Find Greatest Common Divisor of Array.java

---
 Easy/Find Greatest Common Divisor of Array.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Find Greatest Common Divisor of Array.java

diff --git a/Easy/Find Greatest Common Divisor of Array.java b/Easy/Find Greatest Common Divisor of Array.java
new file mode 100644
index 00000000..9e41f8fc
--- /dev/null
+++ b/Easy/Find Greatest Common Divisor of Array.java	
@@ -0,0 +1,9 @@
+import java.math.BigInteger;
+
+
+class Solution {
+  public int findGCD(int[] nums) {
+    return BigInteger.valueOf(Arrays.stream(nums).max().orElse(1))
+        .gcd(BigInteger.valueOf(Arrays.stream(nums).min().orElse(1))).intValue();
+  }
+}

From 869df5ca31375028c60b4b51c0e423b0a53076e4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 25 Aug 2021 07:24:29 -0700
Subject: [PATCH 0564/2175] Update and rename Sum of square numbers.java to Sum
 of Square Numbers.java

---
 Easy/Sum of Square Numbers.java | 17 +++++++++++++++++
 Easy/Sum of square numbers.java | 20 --------------------
 2 files changed, 17 insertions(+), 20 deletions(-)
 create mode 100644 Easy/Sum of Square Numbers.java
 delete mode 100644 Easy/Sum of square numbers.java

diff --git a/Easy/Sum of Square Numbers.java b/Easy/Sum of Square Numbers.java
new file mode 100644
index 00000000..61e26dde
--- /dev/null
+++ b/Easy/Sum of Square Numbers.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean judgeSquareSum(int c) {
+    int left = 0;
+    int right = (int) Math.sqrt(c);
+    while (left <= right) {
+      int currSquareSum = left * left + right * right;
+      if (currSquareSum < c) {
+        left++;
+      } else if (currSquareSum > c) {
+        right--;
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+}
diff --git a/Easy/Sum of square numbers.java b/Easy/Sum of square numbers.java
deleted file mode 100644
index cd8e6598..00000000
--- a/Easy/Sum of square numbers.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-    public boolean judgeSquareSum(int c) {
-        int a = 0;
-        int b = (int)Math.sqrt(c);
-        
-        while (a <= b) {
-            int temp = a*a + b*b;
-            if (temp < c) {
-                a++;
-            }
-            else if (temp > c) {
-                b--;
-            }
-            else {
-                return true;
-            }
-        }
-        return false;
-    }
-}

From 8bd75fd857f3514686f93a413e1eadda32089472 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 Aug 2021 07:38:21 -0700
Subject: [PATCH 0565/2175] Update Verify Preorder Serialization of a Binary
 Tree.java

---
 ...eorder Serialization of a Binary Tree.java | 33 +++++++------------
 1 file changed, 12 insertions(+), 21 deletions(-)

diff --git a/Medium/Verify Preorder Serialization of a Binary Tree.java b/Medium/Verify Preorder Serialization of a Binary Tree.java
index 3e1b5151..db43f945 100644
--- a/Medium/Verify Preorder Serialization of a Binary Tree.java	
+++ b/Medium/Verify Preorder Serialization of a Binary Tree.java	
@@ -1,24 +1,15 @@
 class Solution {
-    public boolean isValidSerialization(String preorder) {
-        Stack<String> stack = new Stack<>();
-        String[] array = preorder.split(",");
-        
-        for (String node : array) {
-            if (node.equals("#")) {
-                while (!stack.isEmpty() && stack.peek().equals("#")) {
-                    stack.pop();
-                    if (stack.isEmpty()) {
-                        return false;
-                    }
-                    stack.pop();
-                }
-                stack.push(node);
-            }
-            else {
-                stack.push(node);
-            }
-        }
-        
-        return stack.size() == 1 && stack.peek().equals("#");
+  public boolean isValidSerialization(String preorder) {
+    String[] nodes = preorder.split(",");
+    int diff = 1;
+    for (String node : nodes) {
+      if (--diff < 0) {
+        return false;
+      }
+      if (!node.equals("#")) {
+        diff += 2;
+      }
     }
+    return diff == 0;
+  }
 }

From 3cd74fda27a987c5eb032d0da9e903d4d116686e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 29 Aug 2021 10:50:12 -0700
Subject: [PATCH 0566/2175] Create Minimum Difference Between Highest and
 Lowest of K Scores.java

---
 ...rence Between Highest and Lowest of K Scores.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Minimum Difference Between Highest and Lowest of K Scores.java

diff --git a/Easy/Minimum Difference Between Highest and Lowest of K Scores.java b/Easy/Minimum Difference Between Highest and Lowest of K Scores.java
new file mode 100644
index 00000000..e9b93530
--- /dev/null
+++ b/Easy/Minimum Difference Between Highest and Lowest of K Scores.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int minimumDifference(int[] nums, int k) {
+    Arrays.sort(nums);
+    int left = 0;
+    int right = k - 1;
+    int minDiff = Integer.MAX_VALUE;
+    while (right < nums.length) {
+      minDiff = Math.min(minDiff, nums[right++] - nums[left++]);
+    }
+    return minDiff;
+  }
+}

From 957411d52ec06b74367989ca7edc29ca82aa48b5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 29 Aug 2021 20:22:39 -0700
Subject: [PATCH 0567/2175] Create Find the Kth Largest Integer in the
 Array.java

---
 Medium/Find the Kth Largest Integer in the Array.java | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Medium/Find the Kth Largest Integer in the Array.java

diff --git a/Medium/Find the Kth Largest Integer in the Array.java b/Medium/Find the Kth Largest Integer in the Array.java
new file mode 100644
index 00000000..cc335042
--- /dev/null
+++ b/Medium/Find the Kth Largest Integer in the Array.java	
@@ -0,0 +1,7 @@
+class Solution {
+  public String kthLargestNumber(String[] nums, int k) {
+    Arrays.sort(nums, (o1, o2) ->
+        o1.length() == o2.length() ? o1.compareTo(o2) : o1.length() - o2.length());
+    return nums[nums.length - k];
+  }
+}

From 453d8f8e4cc2b27eafc6736203d437b7e5c0f838 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 29 Aug 2021 20:27:05 -0700
Subject: [PATCH 0568/2175] Moving files & updating README

---
 ...if Word Equals Summation of Two Words.java |   0
 Easy/README.md                                | 732 +++++++++------
 Hard/Longest Consecutive Sequence.java        |  27 -
 Hard/README.md                                | 118 +--
 .../Longest Consecutive Sequence.java         |   0
 Medium/README.md                              | 876 +++++++++++-------
 6 files changed, 1058 insertions(+), 695 deletions(-)
 rename Check if Word Equals Summation of Two Words.java => Easy/Check if Word Equals Summation of Two Words.java (100%)
 delete mode 100644 Hard/Longest Consecutive Sequence.java
 rename Longest Consecutive Sequence  Solution.java => Medium/Longest Consecutive Sequence.java (100%)

diff --git a/Check if Word Equals Summation of Two Words.java b/Easy/Check if Word Equals Summation of Two Words.java
similarity index 100%
rename from Check if Word Equals Summation of Two Words.java
rename to Easy/Check if Word Equals Summation of Two Words.java
diff --git a/Easy/README.md b/Easy/README.md
index b9713c84..423b1cfa 100644
--- a/Easy/README.md
+++ b/Easy/README.md
@@ -1,284 +1,454 @@
 # Easy LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
-2|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
-3|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
-4|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
-5|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
-6|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
-7|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
-8|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
-9|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20and%20Say.java)
-10|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
-11|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
-12|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
-13|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
-14|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
-15|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
-16|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
-17|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
-18|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
-19|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
-20|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Area%20of%20Island.java)
-21|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
-22|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance%20III.java)
-23|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Compression.java)
-24|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
-25|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
-26|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
-27|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
-28|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20node%20in%20a%20linked%20list.java)
-29|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
-30|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
-31|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
-32|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
-33|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
-34|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20left%20leaves.java)
-35|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
-36|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
-37|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
-38|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
-39|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
-40|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
-41|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
-42|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
-43|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
-44|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
-45|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
-46|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
-47|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
-48|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
-49|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
-50|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/sum_of_two_integers.java)
-51|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
-52|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
-53|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
-54|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
-55|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
-56|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
-57|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
-58|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
-59|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
-60|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
-61|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java)
-62|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/contains_duplicates.java)
-63|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
-64|[Valid Parantheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parantheses.java)
-65|[remove_duplicates_sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/remove_duplicates_sorted.java)
-66|[Sum of square numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20square%20numbers.java)
-67|[add_digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/add_digit.java)
-68|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
-69|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
-70|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
-71|[Power of three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20three.java)
-72|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
-73|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
-74|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
-75|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
-76|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
-77|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
-78|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
-79|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
-80|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
-81|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
-82|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
-83|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum%20III.java)
-84|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
-85|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
-86|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
-87|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
-88|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
-89|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
-90|[ugly_number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/ugly_number.java)
-91|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
-92|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
-93|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
-94|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
-95|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
-96|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
-97|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Trim%20a%20Binary%20Search%20Tree.java)
-98|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
-99|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
-100|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
-101|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance%20II.java)
-102|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
-103|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
-104|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
-105|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
-106|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Level%20Order%20Traversal.java)
-107|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
-108|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
-109|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Anagrams%20in%20a%20String.java)
-110|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
-111|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
-112|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20Array.java)
-113|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
-114|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
-115|[majority_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/majority_element.java)
-116|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
-117|[power_of_2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/power_of_2.java)
-118|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
-119|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
-120|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
-121|[Convert BST to greater tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20greater%20tree.java)
-122|[valid_anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/valid_anagrams.java)
-123|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
-124|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
-125|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
-126|[first_unique_character_in_a_string](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/first_unique_character_in_a_string.java)
-127|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
-128|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
-129|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subdomain%20Visit%20Count.java)
-130|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
-131|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
-132|[FizzBuzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/FizzBuzz.java)
-133|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
-134|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
-135|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
-136|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
-137|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
-138|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
-139|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
-140|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
-141|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
-142|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
-143|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
-144|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
-145|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
-146|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
-147|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
-148|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
-149|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
-150|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
-151|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
-152|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
-153|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
-154|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
-155|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
-156|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
-157|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
-158|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
-159|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotting%20Oranges.java)
-160|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
-161|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20time%20to%20buy%20&%20sell%20a%20stock%20II.java)
-162|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
-163|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
-164|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
-165|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
-166|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
-167|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
-168|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
-169|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
-170|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
-171|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
-172|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
-173|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20II.java)
-174|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
-175|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
-176|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
-177|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
-178|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
-179|[Merge Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Arrays.java)
-180|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
-181|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20arrays%20II.java)
-182|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20City%20Scheduling.java)
-183|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
-184|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
-185|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
-186|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
-187|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
-188|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
-189|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
-190|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
-191|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
-192|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
-193|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
-194|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
-195|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
-196|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Integer.java)
-197|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
-198|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotated%20Digits.java)
-199|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
-200|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
-201|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
-202|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
-203|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
-204|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20three%20numbers.java)
-205|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
-206|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
-207|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
-208|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
-209|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
-210|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
-211|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
-212|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Stack.java)
-213|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
-214|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Unsorted%20Continuous%20Subarray.java)
-215|[Missing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Numbers.java)
-216|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
-217|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
-218|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Stack.java)
-219|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
-220|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
-221|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
-222|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
-223|[Average of levels in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20levels%20in%20a%20binary%20tree.java)
-224|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
-225|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
-226|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
-227|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
-228|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
-229|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbrevation.java)
-230|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
-231|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
-232|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bold%20Words%20in%20String.java)
-233|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
-234|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
-235|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Non-decreasing%20Array.java)
-236|[remove_element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/remove_element.java)
-237|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
-238|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
-239|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Even%20Numbers%20After%20Queries.java)
-240|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
-241|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
-242|[intersection_of_two_arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/intersection_of_two_arrays.java)
-243|[move_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/move_zeroes.java)
-244|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
-245|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
-246|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
-247|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/House%20Robber.java)
-248|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Distance%20to%20Closest%20Person.java)
-249|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20four.java)
-250|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
-251|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
-252|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
-253|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
-254|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
-255|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
-256|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
-257|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Closest%20Points%20to%20Origin.java)
-258|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
-259|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
-260|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
-261|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Numbers.java)
-262|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
-263|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
-264|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
-265|[Best time to buy & sell a stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20time%20to%20buy%20&%20sell%20a%20stock.java)
-266|[Invert a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20a%20binary%20tree.java)
-267|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
-268|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
-269|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
-270|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
-271|[Range Sum Query_Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query_Immutable.java)
-272|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
-273|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
-274|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
-275|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
-276|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
-277|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
-278|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
-279|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
-280|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
-281|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
+1|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
+2|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
+3|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
+4|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
+5|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Stack.java)
+6|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
+7|[Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
+8|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
+9|[Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
+10|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
+11|[Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
+12|[Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
+13|[The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
+14|[Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
+15|[Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
+16|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
+17|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
+18|[Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
+19|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
+20|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bold%20Words%20in%20String.java)
+21|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
+22|[Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
+23|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
+24|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
+25|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
+26|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
+27|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
+28|[Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
+29|[Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
+30|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
+31|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
+32|[X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
+33|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Integer.java)
+34|[Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
+35|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
+36|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
+37|[Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
+38|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
+39|[Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
+40|[Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
+41|[Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
+42|[Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
+43|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
+44|[Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
+45|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Non-decreasing%20Array.java)
+46|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
+47|[Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
+48|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
+49|[Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
+50|[Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
+51|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
+52|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
+53|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
+54|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
+55|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20four.java)
+56|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
+57|[Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
+58|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
+59|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
+60|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
+61|[Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
+62|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
+63|[Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
+64|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
+65|[Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
+66|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
+67|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
+68|[Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
+69|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
+70|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
+71|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
+72|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
+73|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
+74|[Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
+75|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
+76|[Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
+77|[Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
+78|[Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
+79|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
+80|[Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
+81|[Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
+82|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
+83|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
+84|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
+85|[Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
+86|[Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
+87|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
+88|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
+89|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
+90|[Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
+91|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
+92|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
+93|[Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
+94|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
+95|[Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
+96|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
+97|[Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
+98|[Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
+99|[Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
+100|[Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
+101|[Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
+102|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20and%20Say.java)
+103|[Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
+104|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
+105|[Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
+106|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
+107|[Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
+108|[Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
+109|[DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
+110|[Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
+111|[Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
+112|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
+113|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
+114|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
+115|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
+116|[Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
+117|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20three%20numbers.java)
+118|[Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
+119|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
+120|[Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
+121|[Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
+122|[Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
+123|[Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
+124|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
+125|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
+126|[Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
+127|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
+128|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
+129|[Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
+130|[Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
+131|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
+132|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
+133|[Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
+134|[Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
+135|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
+136|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
+137|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
+138|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
+139|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
+140|[Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
+141|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
+142|[Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
+143|[Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reorder%20Data%20in%20Log%20Files.java)
+144|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
+145|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
+146|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
+147|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
+148|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
+149|[Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
+150|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Area%20of%20Island.java)
+151|[Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
+152|[Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
+153|[String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
+154|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
+155|[Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
+156|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
+157|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
+158|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
+159|[Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
+160|[Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
+161|[Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
+162|[Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
+163|[Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
+164|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
+165|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
+166|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotated%20Digits.java)
+167|[Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
+168|[Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
+169|[Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
+170|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
+171|[Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
+172|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/House%20Robber.java)
+173|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
+174|[Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
+175|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
+176|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
+177|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
+178|[Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
+179|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
+180|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
+181|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
+182|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
+183|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
+184|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
+185|[Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
+186|[Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
+187|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20II.java)
+188|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
+189|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
+190|[Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
+191|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20left%20leaves.java)
+192|[Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
+193|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
+194|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
+195|[Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java)
+196|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
+197|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
+198|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Closest%20Points%20to%20Origin.java)
+199|[Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Time%20for%20Given%20Digits.java)
+200|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
+201|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
+202|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
+203|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
+204|[Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
+205|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
+206|[Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
+207|[Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
+208|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
+209|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
+210|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
+211|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
+212|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbrevation.java)
+213|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
+214|[Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
+215|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
+216|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Anagrams%20in%20a%20String.java)
+217|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
+218|[Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
+219|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
+220|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
+221|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
+222|[How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
+223|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
+224|[Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
+225|[Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
+226|[Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
+227|[Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
+228|[Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
+229|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Stack.java)
+230|[Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
+231|[Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
+232|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
+233|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
+234|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
+235|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
+236|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
+237|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
+238|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
+239|[Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
+240|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
+241|[Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
+242|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
+243|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
+244|[Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
+245|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Level%20Order%20Traversal.java)
+246|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
+247|[First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
+248|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
+249|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
+250|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
+251|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
+252|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subdomain%20Visit%20Count.java)
+253|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
+254|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
+255|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
+256|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
+257|[Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
+258|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
+259|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
+260|[Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
+261|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
+262|[Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
+263|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
+264|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
+265|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Even%20Numbers%20After%20Queries.java)
+266|[Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
+267|[Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
+268|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20arrays%20II.java)
+269|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
+270|[Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
+271|[Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
+272|[Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
+273|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
+274|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
+275|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
+276|[Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
+277|[Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
+278|[Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
+279|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
+280|[Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
+281|[Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
+282|[Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
+283|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
+284|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
+285|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
+286|[Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
+287|[Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
+288|[Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
+289|[Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
+290|[Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
+291|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
+292|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
+293|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
+294|[Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
+295|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java)
+296|[Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
+297|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
+298|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
+299|[Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
+300|[Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
+301|[Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
+302|[Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
+303|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
+304|[Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
+305|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
+306|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java)
+307|[Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
+308|[Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
+309|[Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java)
+310|[Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
+311|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20time%20to%20buy%20&%20sell%20a%20stock%20II.java)
+312|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
+313|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
+314|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
+315|[Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
+316|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
+317|[Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
+318|[Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
+319|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
+320|[Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
+321|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
+322|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
+323|[Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
+324|[Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
+325|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
+326|[Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
+327|[Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java)
+328|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Compression.java)
+329|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
+330|[Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
+331|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
+332|[Leaf Similar Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf%20Similar%20Tree.java)
+333|[Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
+334|[Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
+335|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
+336|[Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
+337|[Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
+338|[Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
+339|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
+340|[Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
+341|[Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
+342|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
+343|[Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
+344|[Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
+345|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
+346|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
+347|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20node%20in%20a%20linked%20list.java)
+348|[Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
+349|[Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
+350|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
+351|[Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
+352|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
+353|[Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
+354|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
+355|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
+356|[Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
+357|[Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
+358|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
+359|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
+360|[Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
+361|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
+362|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
+363|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
+364|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
+365|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
+366|[Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
+367|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
+368|[Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
+369|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
+370|[Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
+371|[Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
+372|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
+373|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
+374|[Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
+375|[Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
+376|[Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
+377|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
+378|[Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java)
+379|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
+380|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20City%20Scheduling.java)
+381|[Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
+382|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/contains_duplicates.java)
+383|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
+384|[Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
+385|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
+386|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
+387|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
+388|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum%20III.java)
+389|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
+390|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
+391|[Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
+392|[Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java)
+393|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
+394|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
+395|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
+396|[Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
+397|[Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
+398|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
+399|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
+400|[Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
+401|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
+402|[Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
+403|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
+404|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
+405|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
+406|[Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
+407|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
+408|[Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
+409|[Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
+410|[Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
+411|[Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
+412|[Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
+413|[Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
+414|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
+415|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Numbers.java)
+416|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
+417|[Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
+418|[Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
+419|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
+420|[Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
+421|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
+422|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
+423|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
+424|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
+425|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
+426|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
+427|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
+428|[Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
+429|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
+430|[Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
+431|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Unsorted%20Continuous%20Subarray.java)
+432|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
+433|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
+434|[Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java)
+435|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
+436|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
+437|[Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
+438|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
+439|[Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
+440|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/sum_of_two_integers.java)
+441|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
+442|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
+443|[Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
+444|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
+445|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
+446|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
+447|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
+448|[Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
+449|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
+450|[Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java)
+451|[Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
diff --git a/Hard/Longest Consecutive Sequence.java b/Hard/Longest Consecutive Sequence.java
deleted file mode 100644
index 9ba20263..00000000
--- a/Hard/Longest Consecutive Sequence.java	
+++ /dev/null
@@ -1,27 +0,0 @@
-class Solution {
-    public int longestConsecutive(int[] nums) {
-        Set<Integer> set = new HashSet<>();
-        for (int num : nums) {
-            set.add(num);
-        }
-        
-        int maxLen = 0;
-        Iterator<Integer> iterator = set.iterator();
-        while (iterator.hasNext()) {
-            int num = iterator.next();
-            if (!set.contains(num - 1)) {
-                int current = num;
-                int currLen = 1;
-                
-                while (set.contains(current + 1)) {
-                    current += 1;
-                    currLen++;
-                }
-                
-                maxLen = Math.max(maxLen, currLen);
-            }
-        }
-        
-        return maxLen;
-    }
-}
diff --git a/Hard/README.md b/Hard/README.md
index 3bf228e4..06ab9137 100644
--- a/Hard/README.md
+++ b/Hard/README.md
@@ -1,57 +1,69 @@
 # Hard LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
-2|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
-3|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
-4|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20PostOrder%20Traversal.java)
-5|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
-6|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
-7|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parallel%20Courses.java)
-8|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
-9|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
-10|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
-11|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
-12|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
-13|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
-14|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Consecutive%20Sequence.java)
-15|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
-16|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
-17|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md)
-18|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
-19|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
-20|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
-21|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
-22|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
-23|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
-24|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
-25|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LRU%20Cache.java)
-26|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
-27|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
-28|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
-29|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
-30|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
-31|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
-32|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
-33|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
-34|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
-35|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
-36|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
-37|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20From%20Data%20Stream.java)
-38|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
-39|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
-40|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
-41|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
-42|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
-43|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+1|[Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
+2|[Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
+3|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
+4|[Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
+5|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
+6|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
+7|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
+8|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
+9|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
+10|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
+11|[Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Interval.java)
+12|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
+13|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
+14|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
+15|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
+16|[Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
+17|[Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
+18|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parallel%20Courses.java)
+19|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
+20|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
+21|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
+22|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
+23|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
+24|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
+25|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
+26|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
+27|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
+28|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
+29|[Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
+30|[Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
+31|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
+32|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
+33|[Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
+34|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
+35|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LRU%20Cache.java)
+36|[Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
+37|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
+38|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
+39|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md)
+40|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
+41|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
+42|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
+43|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20From%20Data%20Stream.java)
 44|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
-45|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
-46|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
-47|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
-48|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Interleaving%20String.java)
-49|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
-50|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
-51|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
-52|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
-53|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
-54|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
+45|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+46|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
+47|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
+48|[Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
+49|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
+50|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
+51|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Interleaving%20String.java)
+52|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
+53|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
+54|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
+55|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
+56|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
+57|[Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
+58|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
+59|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
+60|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
+61|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20PostOrder%20Traversal.java)
+62|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
+63|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
+64|[Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
+65|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
+66|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
diff --git a/Longest Consecutive Sequence  Solution.java b/Medium/Longest Consecutive Sequence.java
similarity index 100%
rename from Longest Consecutive Sequence  Solution.java
rename to Medium/Longest Consecutive Sequence.java
diff --git a/Medium/README.md b/Medium/README.md
index 3907727e..549b4e57 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -1,337 +1,545 @@
 # Medium LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
-2|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
-3|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
-4|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
-5|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
-6|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
-7|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
-8|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
-9|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
-10|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
-11|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
-12|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
-13|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
-14|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
-15|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
-16|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
-17|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
-18|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
-19|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
-20|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
-21|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
-22|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
-23|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
-24|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
-25|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
-26|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
-27|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
-28|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
-29|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
-30|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
-31|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
-32|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
-33|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
-34|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
-35|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
-36|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
-37|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
-38|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
-39|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
-40|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
-41|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
-42|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
-43|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
-44|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
-45|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
-46|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
-47|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
-48|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
-49|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
-50|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
-51|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
-52|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
-53|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
-54|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Counting%20Bits.java)
-55|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20into%20Parts.java)
-56|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
-57|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
-58|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
-59|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
-60|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
-61|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
-62|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
-63|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
-64|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
-65|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
-66|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
-67|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
-68|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
-69|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
-70|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Itinerary.java)
-71|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
-72|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
-73|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
-74|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
-75|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
-76|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
-77|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Subsequence.java)
-78|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
-79|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
-80|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
-81|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
-82|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
-83|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20and%20Search%20Word%20-%20Data%20structure%20design.java)
-84|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
-85|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
-86|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
-87|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
-88|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
-89|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
-90|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
-91|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
-92|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
-93|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
-94|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
-95|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
-96|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
-97|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
-98|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
-99|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
-100|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
-101|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
-102|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
-103|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
-104|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
-105|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
-106|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
-107|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
-108|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
-109|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
-110|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
-111|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
-112|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
-113|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
-114|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
-115|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md)
-116|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Inorder%20Traversal.java)
-117|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
-118|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
-119|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
-120|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
-121|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
-122|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
-123|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
-124|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
-125|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
-126|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
-127|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
-128|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
-129|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
-130|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
-131|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
-132|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
-133|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
-134|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
-135|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
-136|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
-137|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
-138|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
-139|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
-140|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
-141|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
-142|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
-143|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
-144|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
-145|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
-146|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
-147|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
-148|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
-149|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
-150|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
-151|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
-152|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
-153|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
-154|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
-155|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
-156|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
-157|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
-158|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
-159|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
-160|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
-161|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
-162|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
-163|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
-164|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
-165|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
-166|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
-167|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
-168|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
-169|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
-170|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
-171|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
-172|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
-173|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
-174|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
-175|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
-176|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
-177|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
-178|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
-179|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
-180|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
-181|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
-182|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
-183|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
-184|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
-185|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
-186|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
-187|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
-188|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
-189|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
-190|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
-191|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
-192|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
-193|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
-194|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20duplicate%20number.java)
-195|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
-196|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
-197|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
-198|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
-199|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
-200|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
-201|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
-202|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
-203|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
-204|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
-205|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
-206|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
-207|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
-208|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
-209|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
-210|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
-211|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
-212|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
-213|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
-214|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
-215|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
-216|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
-217|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
-218|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
-219|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
-220|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
-221|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
-222|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
-223|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
-224|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
-225|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulls%20and%20Cows.java)
-226|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
-227|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
-228|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
-229|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
-230|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Ranges.java)
-231|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
-232|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
-233|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
-234|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
-235|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
-236|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
-237|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
-238|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
-239|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
-240|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
-241|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
-242|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
-243|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
-244|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
-245|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
-246|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
-247|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
-248|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
-249|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
-250|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
-251|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
-252|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
-253|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
-254|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
-255|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vertical%20Order%20Traversal%20Of%20Binary%20Tree.java)
-256|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
-257|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
-258|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Overlap.java)
-259|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
-260|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
-261|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
-262|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
-263|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
-264|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
-265|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
-266|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
-267|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
-268|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
-269|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
-270|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
-271|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
-272|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
-273|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
-274|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
-275|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
-276|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
-277|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
-278|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
-279|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
-280|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
-281|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
-282|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
-283|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
-284|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
-285|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
-286|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer(atoi).java)
-287|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
-288|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
-289|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
-290|[Swap Nodes in Pair](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pair.java)
-291|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
-292|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Teemo%20Attacking.java)
-293|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
-294|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
-295|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
-296|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
-297|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
-298|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
-299|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
-300|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
-301|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
-302|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
-303|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
-304|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
-305|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
-306|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
-307|[Find Largest Value in Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Tree%20Row.java)
-308|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
-309|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
-310|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
-311|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
-312|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
-313|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Summary%20Ranges.java)
-314|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
-315|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
-316|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
-317|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
-318|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
-319|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
-320|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
-321|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
-322|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
-323|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
-324|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
-325|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
-326|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
-327|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
-328|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
-329|[Reverse Nodes in k-group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20k-group.java)
-330|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
-331|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
-332|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/Open%20The%20Lock.java)
-333|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/Target%20Sum.java)
-
+1|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
+2|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Ranges.java)
+3|[First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
+4|[Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
+5|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
+6|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
+7|[Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
+8|[House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
+9|[Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
+10|[Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
+11|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
+12|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
+13|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Itinerary.java)
+14|[Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
+15|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
+16|[Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
+17|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
+18|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
+19|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
+20|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
+21|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
+22|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
+23|[Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
+24|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
+25|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
+26|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
+27|[Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
+28|[Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
+29|[Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
+30|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Overlap.java)
+31|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
+32|[Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
+33|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
+34|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
+35|[Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
+36|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
+37|[Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
+38|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
+39|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
+40|[Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
+41|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
+42|[Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
+43|[Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
+44|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
+45|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
+46|[Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
+47|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
+48|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
+49|[Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
+50|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
+51|[Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
+52|[Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
+53|[Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
+54|[Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
+55|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
+56|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
+57|[Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
+58|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
+59|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
+60|[Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
+61|[Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
+62|[Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
+63|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
+64|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
+65|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
+66|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
+67|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
+68|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
+69|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
+70|[Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
+71|[Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
+72|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
+73|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
+74|[Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
+75|[Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
+76|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
+77|[Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
+78|[Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
+79|[Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
+80|[Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
+81|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
+82|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
+83|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
+84|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
+85|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
+86|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
+87|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
+88|[Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
+89|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Town%20Judge.java)
+90|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
+91|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
+92|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
+93|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
+94|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
+95|[Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
+96|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
+97|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
+98|[Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
+99|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
+100|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
+101|[Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
+102|[Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
+103|[Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
+104|[Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
+105|[Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
+106|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
+107|[Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
+108|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
+109|[Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
+110|[Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
+111|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
+112|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
+113|[Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
+114|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
+115|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
+116|[Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
+117|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
+118|[Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
+119|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
+120|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
+121|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
+122|[Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
+123|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
+124|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
+125|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
+126|[Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
+127|[Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
+128|[Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
+129|[House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
+130|[Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
+131|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
+132|[Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
+133|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
+134|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
+135|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
+136|[Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
+137|[Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
+138|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
+139|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
+140|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
+141|[Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
+142|[Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
+143|[Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
+144|[Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
+145|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
+146|[Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
+147|[Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
+148|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
+149|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20into%20Parts.java)
+150|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
+151|[Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
+152|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
+153|[Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
+154|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
+155|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
+156|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
+157|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
+158|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
+159|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
+160|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
+161|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
+162|[Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
+163|[Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
+164|[Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
+165|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
+166|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
+167|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
+168|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
+169|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
+170|[Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
+171|[Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
+172|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
+173|[Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
+174|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
+175|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
+176|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
+177|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
+178|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
+179|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
+180|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
+181|[Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
+182|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
+183|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
+184|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
+185|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
+186|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
+187|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
+188|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
+189|[Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
+190|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
+191|[Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
+192|[Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
+193|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
+194|[Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
+195|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
+196|[Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
+197|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
+198|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
+199|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
+200|[Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
+201|[Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
+202|[Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
+203|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
+204|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Inorder%20Traversal.java)
+205|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
+206|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
+207|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
+208|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
+209|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
+210|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
+211|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
+212|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
+213|[Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
+214|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
+215|[Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
+216|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
+217|[Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
+218|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
+219|[Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
+220|[Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
+221|[Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
+222|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Subsequence.java)
+223|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
+224|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
+225|[Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
+226|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
+227|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
+228|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
+229|[Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
+230|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
+231|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
+232|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
+233|[Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
+234|[Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
+235|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
+236|[Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
+237|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
+238|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
+239|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
+240|[Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
+241|[Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
+242|[All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
+243|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
+244|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
+245|[Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
+246|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
+247|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
+248|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
+249|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
+250|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
+251|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
+252|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
+253|[Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
+254|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
+255|[Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
+256|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
+257|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
+258|[Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
+259|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
+260|[HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
+261|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
+262|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
+263|[Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
+264|[Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
+265|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
+266|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
+267|[Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
+268|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
+269|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
+270|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
+271|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
+272|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
+273|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
+274|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
+275|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
+276|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
+277|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
+278|[Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
+279|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
+280|[Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
+281|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
+282|[The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
+283|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
+284|[Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
+285|[Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
+286|[Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
+287|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
+288|[Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
+289|[Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
+290|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
+291|[Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
+292|[Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
+293|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
+294|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vertical%20Order%20Traversal%20Of%20Binary%20Tree.java)
+295|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
+296|[Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
+297|[Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
+298|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
+299|[Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
+300|[Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
+301|[Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
+302|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
+303|[Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
+304|[Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
+305|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
+306|[4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
+307|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
+308|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
+309|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
+310|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
+311|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
+312|[Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
+313|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
+314|[Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
+315|[Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
+316|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
+317|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
+318|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
+319|[Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
+320|[Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
+321|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
+322|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
+323|[Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
+324|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
+325|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
+326|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
+327|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
+328|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
+329|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
+330|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
+331|[Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
+332|[Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
+333|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
+334|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
+335|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
+336|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
+337|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
+338|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
+339|[Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
+340|[Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
+341|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
+342|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
+343|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
+344|[Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
+345|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20and%20Search%20Word%20-%20Data%20structure%20design.java)
+346|[Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
+347|[Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
+348|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
+349|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
+350|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
+351|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
+352|[Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
+353|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
+354|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
+355|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
+356|[Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
+357|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
+358|[Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
+359|[Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
+360|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
+361|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
+362|[Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
+363|[Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
+364|[Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
+365|[Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
+366|[Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
+367|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
+368|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
+369|[Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
+370|[Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
+371|[Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
+372|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
+373|[Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
+374|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
+375|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
+376|[Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
+377|[Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
+378|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
+379|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
+380|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
+381|[Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
+382|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
+383|[Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
+384|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
+385|[The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
+386|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
+387|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
+388|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
+389|[Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
+390|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
+391|[Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
+392|[Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
+393|[Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
+394|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
+395|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
+396|[Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
+397|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
+398|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
+399|[Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
+400|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
+401|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
+402|[Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
+403|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
+404|[Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
+405|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
+406|[Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
+407|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
+408|[Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
+409|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
+410|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
+411|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Counting%20Bits.java)
+412|[Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
+413|[Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
+414|[Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
+415|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
+416|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
+417|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
+418|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
+419|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
+420|[Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
+421|[132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java)
+422|[Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
+423|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
+424|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20duplicate%20number.java)
+425|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
+426|[Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
+427|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
+428|[Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
+429|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
+430|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
+431|[Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
+432|[Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
+433|[Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
+434|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
+435|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
+436|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
+437|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
+438|[Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
+439|[Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
+440|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
+441|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
+442|[Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
+443|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
+444|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
+445|[Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
+446|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
+447|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
+448|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
+449|[Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
+450|[Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
+451|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
+452|[The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
+453|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
+454|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
+455|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Teemo%20Attacking.java)
+456|[Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
+457|[Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
+458|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
+459|[Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
+460|[Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
+461|[Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
+462|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
+463|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
+464|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
+465|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
+466|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
+467|[Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
+468|[Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
+469|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
+470|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
+471|[Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
+472|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
+473|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
+474|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
+475|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
+476|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
+477|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer(atoi).java)
+478|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
+479|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
+480|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
+481|[Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
+482|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
+483|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
+484|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
+485|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
+486|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
+487|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
+488|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
+489|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
+490|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
+491|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
+492|[Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
+493|[Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
+494|[Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
+495|[Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
+496|[Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
+497|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
+498|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
+499|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
+500|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
+501|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
+502|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
+503|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
+504|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
+505|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
+506|[Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
+507|[People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
+508|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
+509|[All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
+510|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
+511|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
+512|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
+513|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
+514|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
+515|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
+516|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md)
+517|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
+518|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
+519|[Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
+520|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
+521|[Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
+522|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
+523|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
+524|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
+525|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
+526|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
+527|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
+528|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
+529|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
+530|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
+531|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
+532|[Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
+533|[Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
+534|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
+535|[Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
+536|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
+537|[Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
+538|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
+539|[Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
+540|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
+541|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
+542|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)

From 6ce1036a3f74c839a6212219a7e403ce03c5853d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 29 Aug 2021 20:30:14 -0700
Subject: [PATCH 0569/2175] Update README.md

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index cce3209c..b84b9c6d 100644
--- a/README.md
+++ b/README.md
@@ -4,3 +4,9 @@
 
 ## [Current Leetcode profile: Solved 900+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
+
+Problem Category | Count
+--- | --- 
+[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 452
+[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 543
+[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 67

From 288affdc4f772c41e5a6f7a39b1599a47c2f7729 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 4 Sep 2021 22:20:50 -0700
Subject: [PATCH 0570/2175] Create Count Special Quadruplets.java

---
 Easy/Count Special Quadruplets.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Count Special Quadruplets.java

diff --git a/Easy/Count Special Quadruplets.java b/Easy/Count Special Quadruplets.java
new file mode 100644
index 00000000..1c1cdb71
--- /dev/null
+++ b/Easy/Count Special Quadruplets.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int countQuadruplets(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int count = 0;
+    map.put(nums[nums.length - 1], 1);
+    for (int i = nums.length - 2; i > 1; i--) {
+      for (int j = i - 1; j > 0; j--) {
+        for (int k = j - 1; k >= 0; k--) {
+          if (map.containsKey(nums[i] + nums[j] + nums[k])) {
+            count += map.get(nums[i] + nums[j] + nums[k]);
+          }
+        }
+      }
+      map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
+    }
+    return count;
+  }   
+}

From b8f309455de0fe016507f96dcae2f989005eed0c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Sep 2021 06:23:05 -0700
Subject: [PATCH 0571/2175] Update Slowest Key.java

---
 Easy/Slowest Key.java | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/Easy/Slowest Key.java b/Easy/Slowest Key.java
index 958b8b42..3e583542 100644
--- a/Easy/Slowest Key.java	
+++ b/Easy/Slowest Key.java	
@@ -1,19 +1,18 @@
 class Solution {
   public char slowestKey(int[] releaseTimes, String keysPressed) {
-    int maxReleaseTime = 0;
-    int maxReleaseTimeIdx = 0;
-    for (int idx = 0; idx < releaseTimes.length; idx++) {
-      int currentIdx = keysPressed.charAt(idx) - 'a';
-      int currReleaseTime = releaseTimes[idx] - (idx == 0 ? 0 : releaseTimes[idx - 1]);
-      if (currReleaseTime >= maxReleaseTime) {
-        if (currReleaseTime > maxReleaseTime)  {
-          maxReleaseTimeIdx = currentIdx;
-        } else if (currentIdx > maxReleaseTimeIdx) {
-          maxReleaseTimeIdx = currentIdx;
-        }
-        maxReleaseTime = currReleaseTime;
+    int startTime = 0;
+    int maxPressedTime = 0;
+    char keyWithLongestTime = keysPressed.charAt(0);
+    for (int i = 0; i < releaseTimes.length; i++) {
+      int totalTime = releaseTimes[i] - startTime;
+      if (maxPressedTime < totalTime) {
+        keyWithLongestTime = keysPressed.charAt(i);
+        maxPressedTime = totalTime;
+      } else if (maxPressedTime == totalTime && keyWithLongestTime < keysPressed.charAt(i)) {
+        keyWithLongestTime = keysPressed.charAt(i);
       }
+      startTime = releaseTimes[i];
     }
-    return (char) (97 + maxReleaseTimeIdx);
+    return keyWithLongestTime;
   }
 }

From 1b0260e72eafc489cdfa8edc51c141e10982314c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Sep 2021 00:12:33 -0700
Subject: [PATCH 0572/2175] Update Reverse Linked List.java

---
 Easy/Reverse Linked List.java | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Easy/Reverse Linked List.java b/Easy/Reverse Linked List.java
index e729c133..61877d65 100644
--- a/Easy/Reverse Linked List.java	
+++ b/Easy/Reverse Linked List.java	
@@ -3,22 +3,22 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode reverseList(ListNode head) {
-        ListNode prev = null;
-        ListNode curr = head;
-        ListNode next = null;
-        
-        while (curr != null) {
-            next = curr.next;
-            curr.next = prev;
-            prev = curr;
-            curr = next;
-        }
-
-        return prev;
+  public ListNode reverseList(ListNode head) {
+    ListNode prev = null;
+    ListNode next = null;
+    ListNode curr = head;
+    while (curr != null) {
+      next = curr.next;
+      curr.next = prev;
+      prev = curr;
+      curr = next;
     }
+    return prev;
+  }
 }

From 711c9223110336f2437316f10b73722d7c3917b0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Sep 2021 13:30:49 -0700
Subject: [PATCH 0573/2175] Update Shifting Letters.java

---
 Medium/Shifting Letters.java | 50 ++++++++++--------------------------
 1 file changed, 13 insertions(+), 37 deletions(-)

diff --git a/Medium/Shifting Letters.java b/Medium/Shifting Letters.java
index ccdaa3b4..7d1e7c18 100644
--- a/Medium/Shifting Letters.java	
+++ b/Medium/Shifting Letters.java	
@@ -1,40 +1,16 @@
 class Solution {
-    public String shiftingLetters(String S, int[] shifts) {
-        long[] numOfShifts = getNumOfShifts(shifts);
-        String shiftedString = getShiftedString(S, numOfShifts);
-        
-        return shiftedString;
-    }
-    
-    private long[] getNumOfShifts(int[] shifts) {
-        long totalShifts = 0;
-        long[] cumulativeSum = new long[shifts.length];
-        for (int i=0; i<shifts.length; i++) {
-            totalShifts += shifts[i];
-            cumulativeSum[i] = totalShifts;
-        }
-        
-        long[] numOfShifts = new long[shifts.length];
-        
-        for (int i=0; i<shifts.length; i++) {
-            numOfShifts[i] = (totalShifts - (i > 0 ? cumulativeSum[i-1] : 0)) % 26;
-        }
-        
-        return numOfShifts;
-    }
-    
-    private String getShiftedString(String s, long[] numOfShifts) {
-        StringBuilder sb = new StringBuilder();
-        
-        for (int i=0; i<numOfShifts.length; i++) {
-            long shiftedValue = (int) s.charAt(i) + numOfShifts[i];
-            if (shiftedValue > 122) {
-                shiftedValue = 96 + (shiftedValue - 122); 
-            }
-            
-            sb.append((char) shiftedValue);
-        }
-        
-        return sb.toString();
+  public String shiftingLetters(String s, int[] shifts) {
+    long totalShifts = 0;
+    StringBuilder sb = new StringBuilder();
+    for (int i = shifts.length - 1; i >= 0; i--) {
+      totalShifts += shifts[i];
+      sb.append(getShiftedChar(s.charAt(i), totalShifts));
     }
+    return sb.reverse().toString();
+  }
+  
+  private char getShiftedChar(char c, long shifts) {
+    long newAscii = ((int) c) + (shifts % 26);
+    return (char) (newAscii > 122 ? (97 + (newAscii - 122) - 1) : newAscii);
+  }
 }

From 6c7a794d108234df3d9e2273654c9aa62d8e44f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 11 Sep 2021 09:11:49 -0700
Subject: [PATCH 0574/2175] Update Basic Calculator.java

---
 Hard/Basic Calculator.java | 88 ++++++++++++++++----------------------
 1 file changed, 37 insertions(+), 51 deletions(-)

diff --git a/Hard/Basic Calculator.java b/Hard/Basic Calculator.java
index edd9467f..a3d9b119 100644
--- a/Hard/Basic Calculator.java	
+++ b/Hard/Basic Calculator.java	
@@ -1,55 +1,41 @@
 class Solution {
-    public static  int calculate(String s) {
-        Stack<Integer> stack = new Stack<>();
-        int res = 0;
-        int num = 0;
-        int sign = 1;
-        boolean hasNumberStarted = false;
-
-        for (int i=0; i<s.length(); i++) {
-            char c = s.charAt(i);
-
-            if (Character.isDigit(c)) {
-                hasNumberStarted = true;
-                num = num * 10 + (int) (c - '0');
-            }
-            else if (c == '+') {
-                if(!hasNumberStarted) {
-                    continue;
-                }
-                hasNumberStarted = false;
-                res += sign * num;
-                num = 0;
-                sign = 1;
-            }
-            else if (c == '-') {
-                if(!hasNumberStarted) {
-                    sign *= -1;
-                    continue;
-                }
-                hasNumberStarted = false;
-                res += sign * num;
-                num = 0;
-                sign = -1;
-            }
-            else if (c == '(') {
-                stack.push(res);
-                stack.push(sign);
-                sign = 1;
-                res = 0;
-            }
-            else if (c == ')') {
-                res += sign * num;
-                num = 0;
-                res *= stack.pop();
-                res += stack.pop();
-            }
+  public static  int calculate(String s) {
+    Stack<Integer> stack = new Stack<>();
+    int res = 0;
+    int num = 0;
+    int sign = 1;
+    boolean hasNumberStarted = false;
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (Character.isDigit(c)) {
+        hasNumberStarted = true;
+        num = num * 10 + (int) (c - '0');
+      } else if (c == '+' && hasNumberStarted) {
+        hasNumberStarted = false;
+        res += sign * num;
+        num = 0;
+        sign = 1;
+      } else if (c == '-') {
+        if(!hasNumberStarted) {
+          sign *= -1;
+          continue;
         }
-
-        if (num != 0) {
-            res += sign * num;
-        }
-
-        return res;
+        hasNumberStarted = false;
+        res += sign * num;
+        num = 0;
+        sign = -1;
+      } else if (c == '(') {
+        stack.push(res);
+        stack.push(sign);
+        sign = 1;
+        res = 0;
+      } else if (c == ')') {
+        res += sign * num;
+        num = 0;
+        res *= stack.pop(); // For sign
+        res += stack.pop(); // Adding the num in stack
+      }
     }
+    return res + (num != 0 ? sign * num : 0);
+  }
 }

From 317cdc8c3a7d43fd1396f1f9e71a5d36382e703e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Sep 2021 07:00:17 -0700
Subject: [PATCH 0575/2175] Create Reverse Prefix of Word.java

---
 Easy/Reverse Prefix of Word.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Reverse Prefix of Word.java

diff --git a/Easy/Reverse Prefix of Word.java b/Easy/Reverse Prefix of Word.java
new file mode 100644
index 00000000..3799c707
--- /dev/null
+++ b/Easy/Reverse Prefix of Word.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public String reversePrefix(String word, char ch) {
+    for (int i = 0; i < word.length(); i++) {
+      if (word.charAt(i) == ch) {
+        return new StringBuilder().append(word.substring(0, i + 1)).reverse().toString() + word.substring(i + 1);
+      }
+    }
+    return word;
+  }
+}

From 649978e4a515752fb6c9071dd051ab0022f9bedd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Sep 2021 13:52:48 -0700
Subject: [PATCH 0576/2175] Create Number of Pairs of Interchangeable
 Rectangles.java

---
 ...Number of Pairs of Interchangeable Rectangles.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Number of Pairs of Interchangeable Rectangles.java

diff --git a/Medium/Number of Pairs of Interchangeable Rectangles.java b/Medium/Number of Pairs of Interchangeable Rectangles.java
new file mode 100644
index 00000000..e8e6ef9f
--- /dev/null
+++ b/Medium/Number of Pairs of Interchangeable Rectangles.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public long interchangeableRectangles(int[][] rectangles) {
+    return Arrays.stream(rectangles)
+        .collect(Collectors.groupingBy(
+            e -> ((double) e[0]) / e[1], HashMap::new, Collectors.counting()))
+        .values()
+        .stream()
+        .map(v -> (v * (v - 1)) / 2)
+        .reduce(0L, Long::sum);
+  }
+}

From 55f4c046bf130d5a96a190b9c236c0cb9fd1be50 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Sep 2021 06:34:13 -0700
Subject: [PATCH 0577/2175] Update Maximum Number of Balloons.java

---
 Easy/Maximum Number of Balloons.java | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/Easy/Maximum Number of Balloons.java b/Easy/Maximum Number of Balloons.java
index b0553373..018f048c 100644
--- a/Easy/Maximum Number of Balloons.java	
+++ b/Easy/Maximum Number of Balloons.java	
@@ -1,15 +1,17 @@
 class Solution {
-    public int maxNumberOfBalloons(String text) {
-        Map<Character, Integer> map = new HashMap<>();
-        for (Character c : text.toCharArray()) {
-            map.put(c, map.getOrDefault(c, 0) + 1);
-        }
-        int maxCount = 0;
-        maxCount = map.getOrDefault('l', 0) / 2;
-        maxCount = Math.min(map.getOrDefault('o', 0) / 2, maxCount);
-        maxCount = Math.min(map.getOrDefault('b', 0), maxCount);
-        maxCount = Math.min(map.getOrDefault('a', 0), maxCount);
-        maxCount = Math.min(map.getOrDefault('n', 0), maxCount);
-        return maxCount;
-    }
+  public int maxNumberOfBalloons(String text) {
+    Map<Character, Long> textFrequencyMap = getFrequencyMap(text);
+    Map<Character, Long> ballonFrequencyMap = getFrequencyMap("balloon");
+    return ballonFrequencyMap.keySet().stream()
+        .map(k -> 
+            (int) (textFrequencyMap.getOrDefault(k, 0L) / ballonFrequencyMap.get(k)))
+        .min(Integer::compare)
+        .orElse(0);
+  }
+
+  private Map<Character, Long> getFrequencyMap(String s) {
+    return s.chars()
+        .mapToObj(c -> (char) c)
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
+  }
 }

From 34882197d154e051bdfd87964be6086069baa748 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 14 Sep 2021 06:39:27 -0700
Subject: [PATCH 0578/2175] Update Reverse Only Letters.java

---
 Easy/Reverse Only Letters.java | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/Easy/Reverse Only Letters.java b/Easy/Reverse Only Letters.java
index 95aa10f5..acdd5168 100644
--- a/Easy/Reverse Only Letters.java	
+++ b/Easy/Reverse Only Letters.java	
@@ -1,23 +1,21 @@
 class Solution {
-  public String reverseOnlyLetters(String S) {
+  public String reverseOnlyLetters(String s) {
     int start = 0;
-    int end = S.length() - 1;
-    char[] chars = S.toCharArray();
+    int end = s.length() - 1;
+    char[] letters = s.toCharArray();
     while (start <= end) {
-      while (start <= end && !Character.isLetter(chars[start])) {
+      while (start <= end && !Character.isLetter(s.charAt(start))) {
         start++;
       }
-      while (end >= start && !Character.isLetter(chars[end])) {
+      while (end >= start && !Character.isLetter(s.charAt(end))) {
         end--;
       }
       if (start <= end) {
-        char temp = chars[start];
-        chars[start] = chars[end];
-        chars[end] = temp;
+        char temp = letters[start];
+        letters[start++] = letters[end];
+        letters[end--] = temp;
       }
-      start++;
-      end--;
     }
-    return String.valueOf(chars);
+    return String.valueOf(letters);
   }
 }

From 6c4028b538a86123e6e920c62d97b5c9b37ef993 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 16 Sep 2021 06:16:09 -0700
Subject: [PATCH 0579/2175] Update Spiral Matrix.java

---
 Medium/Spiral Matrix.java | 86 ++++++++++++---------------------------
 1 file changed, 27 insertions(+), 59 deletions(-)

diff --git a/Medium/Spiral Matrix.java b/Medium/Spiral Matrix.java
index 4054cc83..6004fe4d 100644
--- a/Medium/Spiral Matrix.java	
+++ b/Medium/Spiral Matrix.java	
@@ -1,64 +1,32 @@
 class Solution {
-    public List<Integer> spiralOrder(int[][] matrix) {
-        List<Integer> list = new ArrayList<>();
-
-        if (matrix.length == 0 || matrix[0].length == 0) {
-            return list;
+  public List<Integer> spiralOrder(int[][] matrix) {
+    List<Integer> list = new ArrayList<>();
+    int rowStart = 0;
+    int rowEnd = matrix.length - 1;
+    int colStart = 0;
+    int colEnd = matrix[0].length - 1;
+    while (rowStart <= rowEnd && colStart <= colEnd) {
+      for (int i = colStart; i <= colEnd; i++) {
+        list.add(matrix[rowStart][i]);
+      }
+      rowStart++;
+      for (int i = rowStart; i <= rowEnd; i++) {
+        list.add(matrix[i][colEnd]);
+      }
+      colEnd--;
+      if (rowStart <= rowEnd) {
+        for (int i = colEnd; i >= colStart; i--) {
+          list.add(matrix[rowEnd][i]);
         }
-
-        int i = 0;
-        int j = 0;
-        int top = 0;
-        int bottom = matrix.length;
-        int left = 0;
-        int right = matrix[0].length;
-        int dir = 0;
-        int count = 0;
-        int limit = matrix.length * matrix[0].length;
-
-        while (count < limit) {
-            if (dir == 0) {
-                while (j < right) {
-                    list.add(matrix[i][j++]);
-                    count++;
-                }
-                dir++;
-                right--;
-                i++;
-                j--;
-            }
-            else if (dir == 1) {
-                while (i < bottom) {
-                    list.add(matrix[i++][j]);
-                    count++;
-                }
-                dir++;
-                bottom--;
-                i--;
-                j--;
-            }
-            else if (dir == 2) {
-                while (j >= left) {
-                    list.add(matrix[i][j--]);
-                    count++;
-                }
-                dir++;
-                i--;
-                j++;
-                left++;
-            }
-            else if (dir == 3) {
-                while (i > top) {
-                    list.add(matrix[i--][j]);
-                    count++;
-                }
-                dir = 0;
-                top++;
-                i++;
-                j++;
-            }
+        rowEnd--;
+      }
+      if (colStart <= colEnd) {
+        for (int i = rowEnd; i >= rowStart; i--) {
+          list.add(matrix[i][colStart]);
         }
-
-        return list;
+        colStart++;
+      }
     }
+    return list;
+  }
 }

From 4073c797f4bd4276b898cd1cd4eb803cad5ee6ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 17 Sep 2021 07:08:38 -0700
Subject: [PATCH 0580/2175] Update and rename Intersection of two arrays
 II.java to Intersection of Two Arrays II.java

---
 Easy/Intersection of Two Arrays II.java | 14 ++++++++++++++
 Easy/Intersection of two arrays II.java | 20 --------------------
 2 files changed, 14 insertions(+), 20 deletions(-)
 create mode 100644 Easy/Intersection of Two Arrays II.java
 delete mode 100644 Easy/Intersection of two arrays II.java

diff --git a/Easy/Intersection of Two Arrays II.java b/Easy/Intersection of Two Arrays II.java
new file mode 100644
index 00000000..6a6b143d
--- /dev/null
+++ b/Easy/Intersection of Two Arrays II.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int[] intersect(int[] nums1, int[] nums2) {
+    Map<Integer, Long> map = Arrays.stream(nums1).boxed()
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
+    List<Integer> result = new ArrayList<>();
+    for (int num : nums2) {
+      if (map.getOrDefault(num, 0L) > 0) {
+        result.add(num);
+        map.put(num, map.get(num) - 1);
+      }
+    }
+    return result.stream().mapToInt(Integer::valueOf).toArray();
+  }
+}
diff --git a/Easy/Intersection of two arrays II.java b/Easy/Intersection of two arrays II.java
deleted file mode 100644
index 69407386..00000000
--- a/Easy/Intersection of two arrays II.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-  public int[] intersect(int[] nums1, int[] nums2) {
-    Map<Integer, Integer> map = new HashMap<>();
-    for (int num : nums1) {
-      map.put(num, map.getOrDefault(num, 0) + 1);
-    }
-    List<Integer> list = new ArrayList<>();
-    for (int num : nums2) {
-      if (map.getOrDefault(num, 0) > 0) {
-        list.add(num);
-        map.put(num, map.get(num) - 1);
-      } 
-    }
-    int[] ans = new int[list.size()];
-    for (int i = 0; i < list.size(); i++) {
-      ans[i] = list.get(i);
-    }
-    return ans;
-  }
-}

From 1a1c14974af37b7179588aac8dec729d885dc03f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Sep 2021 14:01:51 -0700
Subject: [PATCH 0581/2175] Create Count Number of Pairs With Absolute
 Difference K.java

---
 ...t Number of Pairs With Absolute Difference K.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Count Number of Pairs With Absolute Difference K.java

diff --git a/Easy/Count Number of Pairs With Absolute Difference K.java b/Easy/Count Number of Pairs With Absolute Difference K.java
new file mode 100644
index 00000000..8ff77d76
--- /dev/null
+++ b/Easy/Count Number of Pairs With Absolute Difference K.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int countKDifference(int[] nums, int k) {
+    int count = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      count += map.getOrDefault(num + k, 0);
+      count += map.getOrDefault(num - k, 0);
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    return count;
+  }
+}

From 962882e422b0f2aa85db610db81a99c577e07bac Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Sep 2021 14:33:45 -0700
Subject: [PATCH 0582/2175] Create Find Original Array From Doubled Array.java

---
 ...ind Original Array From Doubled Array.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Find Original Array From Doubled Array.java

diff --git a/Medium/Find Original Array From Doubled Array.java b/Medium/Find Original Array From Doubled Array.java
new file mode 100644
index 00000000..3c4c7dc6
--- /dev/null
+++ b/Medium/Find Original Array From Doubled Array.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int[] findOriginalArray(int[] changed) {
+    if (changed.length % 2 != 0) {
+      return new int[]{};
+    }
+    int[] answer = new int[changed.length / 2];
+    int idx = 0;
+    Map<Integer, Long> map = Arrays.stream(changed).boxed()
+        .collect(Collectors.groupingBy(Function.identity(), TreeMap::new, Collectors.counting()));
+    for (Integer key : map.keySet()) {
+      if (map.get(key) > map.getOrDefault(key * 2, 0L)) {
+        return new int[0];
+      }
+      for (int i = 0; i < map.get(key); i++) {
+        answer[idx++] = key;
+        map.put(key * 2, map.get(key * 2) - 1);
+      }
+    }
+    return answer;
+  }
+}

From a4a74b0221fc5e1a81e701df66bb80e59c723fbf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 Sep 2021 08:02:48 -0700
Subject: [PATCH 0583/2175] Create Final Value of Variable After Performing
 Operations.java

---
 ...al Value of Variable After Performing Operations.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Final Value of Variable After Performing Operations.java

diff --git a/Easy/Final Value of Variable After Performing Operations.java b/Easy/Final Value of Variable After Performing Operations.java
new file mode 100644
index 00000000..1307fdbd
--- /dev/null
+++ b/Easy/Final Value of Variable After Performing Operations.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public int finalValueAfterOperations(String[] operations) {
+    int x = 0;
+    for (String op : operations) {
+      x += op.indexOf('-') != -1 ? -1 : 1;
+    }
+    return x;
+  }
+}

From 4eb2a5ed043e61720047f504dcd89e28f4f14ff0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 19 Sep 2021 17:54:23 -0700
Subject: [PATCH 0584/2175] Updated Contains Duplicate.java to functional style

---
 Easy/Contains Duplicate.java  |  5 +++++
 Easy/contains_duplicates.java | 35 -----------------------------------
 2 files changed, 5 insertions(+), 35 deletions(-)
 create mode 100644 Easy/Contains Duplicate.java
 delete mode 100644 Easy/contains_duplicates.java

diff --git a/Easy/Contains Duplicate.java b/Easy/Contains Duplicate.java
new file mode 100644
index 00000000..156ad8f9
--- /dev/null
+++ b/Easy/Contains Duplicate.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public boolean containsDuplicate(int[] nums) {
+    return Arrays.stream(nums).boxed().collect(Collectors.toSet()).size() < nums.length;
+  }
+}
diff --git a/Easy/contains_duplicates.java b/Easy/contains_duplicates.java
deleted file mode 100644
index e779009b..00000000
--- a/Easy/contains_duplicates.java
+++ /dev/null
@@ -1,35 +0,0 @@
-import java.util.Arrays;
-public class Solution {
-    public boolean containsDuplicate(int[] nums) {
-        int n = nums.length; 
-        Arrays.sort(nums);
-        int c=1;
-        for(int i=0;i<n;i++)
-        {
-            if(i!=n-1)
-            {
-                if(nums[i]==nums[i+1])
-                {
-                    c=0;
-                    break;
-                }
-            }
-        }
-        
-        if(n==0 || n==1)
-        {
-            return false;
-        }
-        else
-        {
-            if(c==0)
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-    }
-}
\ No newline at end of file

From 1ab0ff1daf8ccc052b1669c42af9d024e5f0003b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 21 Sep 2021 06:01:08 -0700
Subject: [PATCH 0585/2175] Update Max Consecutive Ones.java

---
 Easy/Max Consecutive Ones.java | 28 ++++++++++++----------------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/Easy/Max Consecutive Ones.java b/Easy/Max Consecutive Ones.java
index a9ef2478..6f3f557a 100644
--- a/Easy/Max Consecutive Ones.java	
+++ b/Easy/Max Consecutive Ones.java	
@@ -1,20 +1,16 @@
 class Solution {
-    public int findMaxConsecutiveOnes(int[] nums) {
-        int i = 0;
-        int maxOnes = Integer.MIN_VALUE;
-        int temp = 0;
-        while (i < nums.length) {
-            if (nums[i] == 1) {
-                temp++;
-            }
-            else {
-                maxOnes = Math.max(maxOnes, temp);
-                temp = 0;
-            }
-            
-            i++;
+  public int findMaxConsecutiveOnes(int[] nums) {
+    int maxCount = 0;
+    for (int i = 0; i < nums.length; ) {
+      if (nums[i] == 1) {
+        int currIdx = i;
+        while (i < nums.length && nums[i] == 1) {
+          i++;
         }
-        
-        return Math.max(maxOnes, temp);
+        maxCount = Math.max(maxCount, i - currIdx);
+      }
+      i++;
     }
+    return maxCount;
+  }
 }

From 3630d1c72b7eede61cfccc85faab5d64dadacb8b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 21 Sep 2021 10:35:28 -0700
Subject: [PATCH 0586/2175] Update Merge Sorted Array.java

---
 Easy/Merge Sorted Array.java | 20 ++++++--------------
 1 file changed, 6 insertions(+), 14 deletions(-)

diff --git a/Easy/Merge Sorted Array.java b/Easy/Merge Sorted Array.java
index 828d100f..a1baa0d2 100644
--- a/Easy/Merge Sorted Array.java	
+++ b/Easy/Merge Sorted Array.java	
@@ -1,22 +1,14 @@
 class Solution {
   public void merge(int[] nums1, int m, int[] nums2, int n) {
     int idx = m + n - 1;
-    int numsOneIdx = m - 1;
-    int numsTwoIdx = n - 1;
-    while (numsOneIdx >= 0 || numsTwoIdx >= 0) {
-      int val = -1;
-      if (numsOneIdx >= 0 && numsTwoIdx >= 0) {
-        if (nums1[numsOneIdx] > nums2[numsTwoIdx]) {
-          val = nums1[numsOneIdx--];
-        } else {
-          val = nums2[numsTwoIdx--];
-        }
-      } else if (numsOneIdx >= 0 && numsTwoIdx < 0) {
-        val = nums1[numsOneIdx--];
+    while (m > 0 || n > 0) {
+      if (m > 0 && n > 0) {
+        nums1[idx--] = nums1[m - 1] > nums2[n - 1] ? nums1[m-- - 1] : nums2[n-- - 1];
+      } else if (m > 0 && n == 0) {
+        nums1[idx--] = nums1[m-- - 1];
       } else {
-        val = nums2[numsTwoIdx--];
+        nums1[idx--] = nums2[n-- - 1];
       }
-      nums1[idx--] = val;
     }
   }
 }

From da0b398556c54cb219aaed7560e913ebc9c5675f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 23 Sep 2021 09:28:10 -0500
Subject: [PATCH 0587/2175] Update Break a Palindrome.java

---
 Medium/Break a Palindrome.java | 21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

diff --git a/Medium/Break a Palindrome.java b/Medium/Break a Palindrome.java
index eca6bb8b..aa82cbe7 100644
--- a/Medium/Break a Palindrome.java	
+++ b/Medium/Break a Palindrome.java	
@@ -1,24 +1,13 @@
 class Solution {
   public String breakPalindrome(String palindrome) {
-    // If empty or of length 1 => return empty
-    if (palindrome.length() <= 1) {
-      return "";
-    }
     char[] chars = palindrome.toCharArray();
-    for (int i = 0; i < chars.length; i++) {
-      if (chars[i] != 'a') {
-        // Skip if the string is of odd length and it is the middle index
-        if (palindrome.length() % 2 != 0 && i == palindrome.length() / 2) {
-          continue;
-        }
+    for (int i = 0; i < palindrome.length() / 2; i++) {
+      if (chars[i] > 'a') {
         chars[i] = 'a';
-        break;
-      }
-      // If all chars all 'a' update last char to 'b'
-      if (i == chars.length - 1) {
-        chars[i] = 'b';
+        return String.valueOf(chars);
       }
     }
-    return String.valueOf(chars);
+    chars[chars.length - 1] = 'b';
+    return chars.length <= 1 ? "" : String.valueOf(chars);
   }
 }

From 3a076706521d94c7e6ea521ed1122227b5af28ed Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 24 Sep 2021 11:57:43 -0500
Subject: [PATCH 0588/2175] Update N-th Tribonacci Number.java

---
 Easy/N-th Tribonacci Number.java | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/Easy/N-th Tribonacci Number.java b/Easy/N-th Tribonacci Number.java
index cfaaeca9..af3ee26d 100644
--- a/Easy/N-th Tribonacci Number.java	
+++ b/Easy/N-th Tribonacci Number.java	
@@ -1,17 +1,10 @@
 class Solution {
   public int tribonacci(int n) {
-    int[] dp = new int[Math.max(n + 1, 3)];
-    dp[0] = 0;
-    dp[1] = 1;
-    dp[2] = 1;
-    return helper(n, dp);
-  }
-  
-  private int helper(int n, int[] dp) {
-    if (n == 0 || dp[n] != 0) {
-      return dp[n];
+    int[] arr = new int[38];
+    arr[1] = arr[2] = 1;
+    for (int i = 3; i < 38; i++) {
+      arr[i] = arr[i - 1] + arr[i - 2] + arr[i - 3];
     }
-    dp[n] = helper(n - 1, dp) + helper(n - 2, dp) + helper(n - 3, dp);
-    return dp[n];
+    return arr[n];
   }
 }

From c507cfe2ee72f81be00ea6bceddcd5bea2cf7866 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Sep 2021 20:40:32 -0500
Subject: [PATCH 0589/2175] Create Maximum Difference Between Increasing
 Elements.java

---
 ...imum Difference Between Increasing Elements.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Maximum Difference Between Increasing Elements.java

diff --git a/Easy/Maximum Difference Between Increasing Elements.java b/Easy/Maximum Difference Between Increasing Elements.java
new file mode 100644
index 00000000..edb343d1
--- /dev/null
+++ b/Easy/Maximum Difference Between Increasing Elements.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int maximumDifference(int[] nums) {
+    int currMin = nums[0];
+    int maxDiff = -1;
+    for (int i = 0; i < nums.length; i++) {
+      currMin = Math.min(currMin, nums[i]);
+      if (nums[i] != currMin) {
+        maxDiff = Math.max(maxDiff, nums[i] - currMin);
+      }
+    }
+    return maxDiff;
+  } 
+}

From 1a3fe56e39329837b27c40a94f8f27f451e5f930 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 27 Sep 2021 07:16:40 -0500
Subject: [PATCH 0590/2175] Update Unique Email Addresses.java

---
 Easy/Unique Email Addresses.java | 42 ++++++++------------------------
 1 file changed, 10 insertions(+), 32 deletions(-)

diff --git a/Easy/Unique Email Addresses.java b/Easy/Unique Email Addresses.java
index 871d1a0e..ca28017e 100644
--- a/Easy/Unique Email Addresses.java	
+++ b/Easy/Unique Email Addresses.java	
@@ -1,37 +1,15 @@
 class Solution {
   public int numUniqueEmails(String[] emails) {
-    Set<String> set = new HashSet<>();
-    for (String email : emails) {
-      set.add(formattedEmail(email));
-    }
-    return set.size();
+    return Arrays.stream(emails).map(Solution::formatEmail).collect(Collectors.toSet()).size();
   }
-  
-  private String formattedEmail(String s) {
-    StringBuilder sb = new StringBuilder();
-    int i = 0;
-    int n = s.length();
-    boolean plusFound = false;
-    while (i < n) {
-      char c = s.charAt(i);
-      if (c == '@') {
-        break;
-      }
-      if (plusFound) {
-        i++;
-        continue;
-      }
-      else if (c == '+') {
-        plusFound = true;
-      }
-      else if (c != '.') {
-        sb.append(c);
-      }
-      i++;
-    }
-    while (i < n) {
-      sb.append(s.charAt(i++));
-    }
-    return sb.toString();
+
+  private static String formatEmail(String email) {
+    String localName = email.split("@")[0];
+    return (localName.indexOf('+') != -1
+                ? localName.substring(0, localName.indexOf('+'))
+                : localName)
+            .replaceAll("\\.", "")
+        + "@"
+        + email.split("@")[1];
   }
 }

From 2392874999b55a708e94e3c9f3b3fdedcf912a6c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 29 Sep 2021 08:44:22 -0500
Subject: [PATCH 0591/2175] Update and rename Split Linked List into Parts.java
 to Split Linked List in Parts.java

---
 Medium/Split Linked List in Parts.java   | 31 +++++++++++++++++
 Medium/Split Linked List into Parts.java | 44 ------------------------
 2 files changed, 31 insertions(+), 44 deletions(-)
 create mode 100644 Medium/Split Linked List in Parts.java
 delete mode 100644 Medium/Split Linked List into Parts.java

diff --git a/Medium/Split Linked List in Parts.java b/Medium/Split Linked List in Parts.java
new file mode 100644
index 00000000..30121c82
--- /dev/null
+++ b/Medium/Split Linked List in Parts.java	
@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+*/
+class Solution {
+  public ListNode[] splitListToParts(ListNode head, int k) {
+    ListNode[] arr = new ListNode[k];
+    int nodeLength = 0;
+    for (ListNode curr = head; curr != null; curr = curr.next) {
+      nodeLength++;
+    }
+    int n = nodeLength / k;
+    int remaining = nodeLength % k;
+    ListNode prev = null;
+    for (int i = 0; i < k && head != null; i++, remaining--) {
+      arr[i] = head;
+      for (int j = 0; j < n + (remaining > 0 ? 1 : 0); j++) {
+        prev = head;
+        head = head.next;
+      }
+      prev.next = null;
+    }
+    return arr;
+  }
+}
diff --git a/Medium/Split Linked List into Parts.java b/Medium/Split Linked List into Parts.java
deleted file mode 100644
index 3fdff43c..00000000
--- a/Medium/Split Linked List into Parts.java	
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-
-class Solution {
-    public ListNode[] splitListToParts(ListNode root, int k) {
-        int m = findLength(root);
-        ListNode temp = root;
-        
-        ListNode[] res = new ListNode[k];
-        int size=m/k;
-        int l= m%k;
-        
-        for(int i=0;i<k;i++){
-            ListNode ans= temp;
-            int j=size;
-            while(temp!=null && j>1){
-                temp=temp.next;j--;
-            }
-            if(size!=0 && l>0 && temp!=null){ temp=temp.next;  l--;}
-            ListNode temp1=temp;
-            if(temp!=null) temp=temp.next;
-            if(temp1!=null) temp1.next=null;
-            res[i]=ans;
-        }
-        return res;
-    }
-    
-    private int findLength(ListNode root) {
-        if (root == null) return 0;
-        int l = 0;
-        while(root != null) {
-            l++;
-            root = root.next;
-        }
-        
-        return l;
-    }
-}

From 1eec20b7efd05beae8fdeab8ea99e29454042190 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Oct 2021 23:30:17 -0500
Subject: [PATCH 0592/2175] Create Minimum Moves to Convert String.java

---
 Easy/Minimum Moves to Convert String.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Minimum Moves to Convert String.java

diff --git a/Easy/Minimum Moves to Convert String.java b/Easy/Minimum Moves to Convert String.java
new file mode 100644
index 00000000..61b7a169
--- /dev/null
+++ b/Easy/Minimum Moves to Convert String.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int minimumMoves(String s) {
+    int numOfMoves = 0;
+    int idx = 0;
+    while (idx < s.length()) {
+      if (s.charAt(idx) == 'X') {
+        idx += 2;
+        numOfMoves++;
+      }
+      idx++;
+    }
+    return numOfMoves;
+  }
+}

From 2b51bee308762c7b4c681796cae9dba37795e6ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Oct 2021 07:22:12 -0500
Subject: [PATCH 0593/2175] Create Convert 1D Array Into 2D Array.java

---
 Easy/Convert 1D Array Into 2D Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Convert 1D Array Into 2D Array.java

diff --git a/Easy/Convert 1D Array Into 2D Array.java b/Easy/Convert 1D Array Into 2D Array.java
new file mode 100644
index 00000000..80b7323e
--- /dev/null
+++ b/Easy/Convert 1D Array Into 2D Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int[][] construct2DArray(int[] original, int m, int n) {
+    if (m * n != original.length) {
+      return new int[][]{};
+    }
+    int[][] arr = new int[m][n];
+    int idx = 0;
+    int arrIdx = 0;
+    while (idx < original.length) {
+      for (int i = 0; i < n; i++) {
+        arr[arrIdx][i] = original[idx++];
+      }
+      arrIdx++;
+    }
+    return arr;
+  }
+}

From 91581fb76b264dc798d4de4b42b984aa7d7db0a6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Oct 2021 08:53:47 -0500
Subject: [PATCH 0594/2175] Create Find Missing Observations.java

---
 Medium/Find Missing Observations.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Find Missing Observations.java

diff --git a/Medium/Find Missing Observations.java b/Medium/Find Missing Observations.java
new file mode 100644
index 00000000..7b738edc
--- /dev/null
+++ b/Medium/Find Missing Observations.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int[] missingRolls(int[] rolls, int mean, int n) {
+    int currSum = Arrays.stream(rolls).sum();
+    int missingSum = mean * (n + rolls.length) - currSum;
+    if (missingSum > n * 6 || missingSum < n) {
+      return new int[]{};
+    }
+    int[] ans = new int[n];
+    int part = missingSum / n;
+    int remainder = missingSum % n;
+    Arrays.fill(ans, part);
+    for (int i = 0; i < remainder; i++) {
+      ans[i]++;
+    }
+    return ans;
+  }
+}

From 9728a5baad19cf43490cc80d50afa686278b8dba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Oct 2021 07:57:59 -0500
Subject: [PATCH 0595/2175] Create Number of Pairs of Strings With
 Concatenation Equal to Target.java

---
 ...ngs With Concatenation Equal to Target.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Number of Pairs of Strings With Concatenation Equal to Target.java

diff --git a/Medium/Number of Pairs of Strings With Concatenation Equal to Target.java b/Medium/Number of Pairs of Strings With Concatenation Equal to Target.java
new file mode 100644
index 00000000..be6a6077
--- /dev/null
+++ b/Medium/Number of Pairs of Strings With Concatenation Equal to Target.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int numOfPairs(String[] nums, String target) {
+    Map<String, Integer> map = new HashMap<>();
+    int count = 0;
+    for (String num : nums) {
+      if (target.startsWith(num)) {
+        String end = target.substring(num.length());
+        count += map.getOrDefault(end, 0);
+      } 
+      if (target.endsWith(num)) {
+        String start = target.substring(0, target.length() - num.length());
+        count += map.getOrDefault(start, 0);
+      }
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    return count;
+  }
+}

From 1b814352898a1578346ae39c0d3dc27ca883870c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Oct 2021 08:24:31 -0500
Subject: [PATCH 0596/2175] Update Word Search.java

---
 Medium/Word Search.java | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Medium/Word Search.java b/Medium/Word Search.java
index f5ed8288..c3574bd4 100644
--- a/Medium/Word Search.java	
+++ b/Medium/Word Search.java	
@@ -1,33 +1,33 @@
 class Solution {
-  public int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  public static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
   public boolean exist(char[][] board, String word) {
-    if (board.length == 0 || board[0].length == 0) {
-      return false;
-    }
+    int rows = board.length;
+    int cols = board[0].length;
     for (int i = 0; i < board.length; i++) {
       for (int j = 0; j < board[0].length; j++) {
-        if (exists(board, i, j, word, 0, new boolean[board.length][board[0].length])) {
+        if (dfs(board, word, 0, new boolean[rows][cols], i, j)) {
           return true;
         }
       }
     }
     return false;
-  } 
-  
-  private boolean exists(char[][] board, int i, int j, String word, int idx, boolean[][] visited) {
+  }
+
+  private boolean dfs(char[][] board, String word, int idx, boolean[][] visited, int i, int j) {
     if (idx == word.length()) {
       return true;
     }
-    if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || visited[i][j] || word.charAt(idx) != board[i][j]) {
+    if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || visited[i][j]
+        || board[i][j] != word.charAt(idx)) {
       return false;
     }
     visited[i][j] = true;
-    for (int[] dir : dirs) {
-      if (exists(board, i + dir[0], j + dir[1], word, idx + 1, visited)) {
-        return true;
-      }
+    boolean ans = false;
+    for (int[] dir : DIRS) {
+      ans = ans || dfs(board, word, idx + 1, visited, i + dir[0], j + dir[1]);
     }
     visited[i][j] = false;
-    return false;
+    return ans;
   }
 }

From 99ca85102e366908d53d6190b5b47a1a8873db91 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Oct 2021 08:35:21 -0500
Subject: [PATCH 0597/2175] Update Word Search.java

---
 Medium/Word Search.java | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/Medium/Word Search.java b/Medium/Word Search.java
index c3574bd4..6eb6993c 100644
--- a/Medium/Word Search.java	
+++ b/Medium/Word Search.java	
@@ -2,11 +2,10 @@ class Solution {
   public static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
   
   public boolean exist(char[][] board, String word) {
-    int rows = board.length;
-    int cols = board[0].length;
+    char[] letters = word.toCharArray();
     for (int i = 0; i < board.length; i++) {
       for (int j = 0; j < board[0].length; j++) {
-        if (dfs(board, word, 0, new boolean[rows][cols], i, j)) {
+        if (dfs(board, 0, letters, i, j)) {
           return true;
         }
       }
@@ -14,20 +13,22 @@ public boolean exist(char[][] board, String word) {
     return false;
   }
 
-  private boolean dfs(char[][] board, String word, int idx, boolean[][] visited, int i, int j) {
-    if (idx == word.length()) {
+  private boolean dfs(char[][] board, int idx, char[] letters, int i, int j) {
+    if (idx == letters.length) {
       return true;
     }
-    if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || visited[i][j]
-        || board[i][j] != word.charAt(idx)) {
+    if (i < 0 || i >= board.length || j < 0 || j >= board[0].length) {
       return false;
     }
-    visited[i][j] = true;
-    boolean ans = false;
+    if (board[i][j] != letters[idx]) {
+      return false;
+    }
+    board[i][j] ^= 256;
+    boolean exists = false;
     for (int[] dir : DIRS) {
-      ans = ans || dfs(board, word, idx + 1, visited, i + dir[0], j + dir[1]);
+      exists = exists || dfs(board, idx + 1, letters, i + dir[0], j + dir[1]);
     }
-    visited[i][j] = false;
-    return ans;
+    board[i][j] ^= 256;
+    return exists;
   }
 }

From 8e104b16402c5e4c0fb3140f3177cd190cfd8ad3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 8 Oct 2021 09:51:00 -0500
Subject: [PATCH 0598/2175] Update Implement Trie (Prefix Tree).java

---
 Medium/Implement Trie (Prefix Tree).java | 81 ++++++++++--------------
 1 file changed, 32 insertions(+), 49 deletions(-)

diff --git a/Medium/Implement Trie (Prefix Tree).java b/Medium/Implement Trie (Prefix Tree).java
index f987662b..f5aaa30e 100644
--- a/Medium/Implement Trie (Prefix Tree).java	
+++ b/Medium/Implement Trie (Prefix Tree).java	
@@ -1,70 +1,53 @@
 class Trie {
 
-  /** Initialize your data structure here. */
-  Node root;
+  TrieNode root;
   public Trie() {
-    root = new Node('-');
+    root = new TrieNode('-');
   }
 
-  /** Inserts a word into the trie. */
   public void insert(String word) {
-    insertHelper(word, 0, root);
-  }
-  
-  private void insertHelper(String word, int idx, Node root) {
-    if (idx >= word.length()) {
-      root.isWord = true;
-      return;
-    }
-    if (!root.children.containsKey(word.charAt(idx))) {
-      root.children.put(word.charAt(idx), new Node(word.charAt(idx)));
+    TrieNode node = root;
+    for (int i = 0; i < word.length(); i++) {
+      if (node.children[word.charAt(i) - 'a'] == null) {
+        node.children[word.charAt(i) - 'a'] = new TrieNode(word.charAt(i));
+      }
+      node = node.children[word.charAt(i) - 'a'];
+      if (i == word.length() - 1) {
+        node.isWord = true;
+      }
     }
-    root = root.children.get(word.charAt(idx));
-    insertHelper(word, idx + 1, root);
   }
 
-  /** Returns if the word is in the trie. */
   public boolean search(String word) {
-    return searchHelper(word, 0, root);
-  }
-  
-  private boolean searchHelper(String word, int idx, Node root) {
-    if (idx == word.length()) {
-      return root.isWord;
-    }
-    if (!root.children.containsKey(word.charAt(idx))) {
-      return false;
-    }
-    root = root.children.get(word.charAt(idx));
-    return searchHelper(word, idx + 1, root);
+    TrieNode node = searchHelper(word);
+    return node != null && node.isWord;
   }
 
-  /** Returns if there is any word in the trie that starts with the given prefix. */
   public boolean startsWith(String prefix) {
-    return startsWithHelper(prefix, 0, root);
+    return searchHelper(prefix) != null;
   }
   
-  private boolean startsWithHelper(String word, int idx, Node root) {
-    if (idx == word.length()) {
-      return true;
-    }
-    if (!root.children.containsKey(word.charAt(idx))) {
-      return false;
+  private TrieNode searchHelper(String word) {
+    TrieNode node = root;
+    for (int i = 0; i < word.length(); i++) {
+      if (node.children[word.charAt(i) - 'a'] == null) {
+        return null;
+      }
+      node = node.children[word.charAt(i) - 'a'];
     }
-    root = root.children.get(word.charAt(idx));
-    return startsWithHelper(word, idx + 1, root);
+    return node;
   }
-}
-
-class Node {
-  char val;
-  Map<Character, Node> children;
-  boolean isWord;
   
-  public Node(char val) {
-    this.val = val;
-    children = new HashMap<>();
-    isWord = false;
+  class TrieNode {
+    TrieNode[] children;
+    boolean isWord;
+    char c;
+    
+    public TrieNode(char c) {
+      this.c = c;
+      children = new TrieNode[26];
+      isWord = false;
+    }
   }
 }
 

From 6843b57e8f1585879e13a455bfdcc5425a7aa1dd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Oct 2021 07:40:36 -0500
Subject: [PATCH 0599/2175] Update Word Search II.java

---
 Hard/Word Search II.java | 112 +++++++++++++++++++--------------------
 1 file changed, 54 insertions(+), 58 deletions(-)

diff --git a/Hard/Word Search II.java b/Hard/Word Search II.java
index 4fd55b93..729cf044 100644
--- a/Hard/Word Search II.java	
+++ b/Hard/Word Search II.java	
@@ -1,66 +1,62 @@
 class Solution {
-    public List<String> findWords(char[][] board, String[] words) {
-        List<String> result = new ArrayList<>();
-        TrieNode root = buildTrie(words);
-
-        for (int i = 0; i < board.length; i++) {
-            for (int j = 0; j < board[0].length; j++) {
-                helper(board, i, j, root, result);
-            }
-        }
-
-        return result;
+  public List<String> findWords(char[][] board, String[] words) {
+    List<String> result = new ArrayList<>();
+    TrieNode root = buildTrie(words);
+    for (int i = 0; i < board.length; i++) {
+      for (int j = 0; j < board[0].length; j++) {
+        dfs(board, i, j, result, root);
+      }
     }
-
-    private void helper(char[][] board, int i, int j, TrieNode root, List<String> result) {
-        if (i < 0 || i >= board.length || j >= board[i].length || j < 0) {
-            return;
-        }
-
-        char c = board[i][j];
-        if (c == '@' || root.next[c - 'a'] == null) {
-            return;
-        }
-
-        root = root.next[c - 'a'];
-        if (root.word != null) {
-            result.add(root.word);
-            root.word = null;
+    return result;
+  }
+  
+  private TrieNode buildTrie(String[] words) {
+    TrieNode root = new TrieNode();
+    for (String word : words) {
+      TrieNode temp = root;
+      for (char c : word.toCharArray()) {
+        if (temp.children[c - 'a'] == null) {
+          temp.children[c - 'a'] = new TrieNode();
         }
-
-        // Choose
-        board[i][j] = '@';
-
-        // Explore
-        helper(board, i + 1, j, root, result);
-        helper(board, i, j + 1, root, result);
-        helper(board, i, j - 1, root, result);
-        helper(board, i - 1, j, root, result);
-
-        // Un-choose
-        board[i][j] = c;
+        temp = temp.children[c - 'a'];
+     }
+       temp.word = word;
     }
+    return root;
+  }
 
-    private TrieNode buildTrie(String[] words) {
-        TrieNode root = new TrieNode();
-        for (String word : words) {
-            TrieNode temp =root;
-            for (char c : word.toCharArray()) {
-                if (temp.next[c - 'a'] == null) {
-                    temp.next[c - 'a'] = new TrieNode();
-                }
-
-                temp = temp.next[c - 'a'];
-            }
-
-            temp.word = word;
-        }
-
-        return root;
+  private void dfs(char[][] board, int i, int j, List<String> result, TrieNode root) {
+    char c = board[i][j];
+    if (c == '#' || root.children[c - 'a'] == null) {
+      return;
     }
-
-    class TrieNode {
-        TrieNode[] next = new TrieNode[26];
-        String word;
+    root = root.children[c - 'a'];
+    if (root.word != null) {
+      result.add(root.word);
+      root.word = null;
+    }
+    board[i][j] = '#';
+    triggerDfsIfValid(board, i, j, result, root);
+    board[i][j] = c;
+  }
+  
+  private void triggerDfsIfValid(char[][] board, int i, int j, List<String> result, TrieNode root) {
+    if (i > 0) {
+      dfs(board, i - 1, j, result, root);
+    }
+    if (j > 0) {
+      dfs(board, i, j - 1, result, root);
+    }
+    if (i < board.length - 1) {
+      dfs(board, i + 1, j, result, root);
+    }
+    if (j < board[0].length - 1) {
+      dfs(board, i, j + 1, result, root);
     }
+  }
+  
+  class TrieNode {
+    TrieNode[] children = new TrieNode[26];
+    String word;
+  }
 }

From 9e00e5dafd33d9b6a50fd0caea586cc6ae7e2929 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Oct 2021 19:55:25 -0500
Subject: [PATCH 0600/2175] Update Bitwise AND of Numbers Range.java

---
 Medium/Bitwise AND of Numbers Range.java | 36 ++++--------------------
 1 file changed, 5 insertions(+), 31 deletions(-)

diff --git a/Medium/Bitwise AND of Numbers Range.java b/Medium/Bitwise AND of Numbers Range.java
index a5823908..c0645dd1 100644
--- a/Medium/Bitwise AND of Numbers Range.java	
+++ b/Medium/Bitwise AND of Numbers Range.java	
@@ -1,34 +1,8 @@
 class Solution {
-    public int rangeBitwiseAnd(int m, int n) {
-        int temp1 = m;
-        int temp2 = n;
-        
-        int cnt1 = 0;
-        int cnt2 = 0;
-        
-        while (temp1 > 1 || temp2 > 1) {
-            if (temp1 > 1) {
-                temp1 /= 2;
-                cnt1++;
-            }     
-            
-            if (temp2 > 1) {
-                temp2 /= 2;
-                cnt2++;
-            } 
-        }
-        
-        if (cnt1 != cnt2) {
-            return 0;
-        }
-        
-        int res = ~0;
-        for (int i=m;i<n;i++) {
-            res = res&i;
-        }
-        
-        res = res&n;
-        
-        return res;
+  public int rangeBitwiseAnd(int left, int right) {
+    while (right > left) {
+      right = right & (right - 1);
     }
+    return left & right;
+  }
 }

From 4c68381b7d83f72cb4096555741fd7a83e87a1cb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Oct 2021 12:01:21 -0500
Subject: [PATCH 0601/2175] Create Two Out of Three.java

---
 Easy/Two Out of Three.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Two Out of Three.java

diff --git a/Easy/Two Out of Three.java b/Easy/Two Out of Three.java
new file mode 100644
index 00000000..7deb6a0b
--- /dev/null
+++ b/Easy/Two Out of Three.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public List<Integer> twoOutOfThree(int[] nums1, int[] nums2, int[] nums3) {
+    Map<Integer, Set<String>> map = new HashMap<>();
+    updateMap(map, nums1, "1");
+    updateMap(map, nums2, "2");
+    updateMap(map, nums3, "3");
+    return map.entrySet()
+      .stream()
+      .filter(entry -> entry.getValue().size() > 1)
+      .map(entry -> entry.getKey())
+      .collect(Collectors.toList());
+  }
+  
+  private void updateMap(Map<Integer, Set<String>> map, int[] nums, String key) {
+    for (int num : nums) {
+      map.computeIfAbsent(num, k -> new HashSet<>()).add(key);
+    }
+  }
+}

From 9248ae38199e2d66ddcd262d84c8b35df0ac3faf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Oct 2021 19:08:30 -0500
Subject: [PATCH 0602/2175] Update Diameter of Binary Tree.java

---
 Easy/Diameter of Binary Tree.java | 38 +++++++++++++++++--------------
 1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/Easy/Diameter of Binary Tree.java b/Easy/Diameter of Binary Tree.java
index d7e874c7..e62673f3 100644
--- a/Easy/Diameter of Binary Tree.java	
+++ b/Easy/Diameter of Binary Tree.java	
@@ -4,25 +4,29 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int diameterOfBinaryTree(TreeNode root) {
-        if (root == null) return 0;
-        
-        int rootDiam = depth(root.left) + depth(root.right);
-        int leftDia = diameterOfBinaryTree(root.left);
-        int rightDia = diameterOfBinaryTree(root.right);
-        
-        return Math.max(rootDiam, Math.max(leftDia, rightDia));
-    }
-    
-    public int depth(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        
-        return 1 + Math.max(depth(root.left), depth(root.right));
+  public int diameterOfBinaryTree(TreeNode root) {
+    int[] diameter = {0};
+    dfs(root, diameter);
+    return diameter[0];
+  }
+  
+  private int dfs(TreeNode root, int[] diameter) {
+    if (root == null) {
+      return 0;
     }
+    int leftDiameter = dfs(root.left, diameter);
+    int rightDiameter = dfs(root.right, diameter);
+    diameter[0] = Math.max(leftDiameter + rightDiameter, diameter[0]);
+    return Math.max(leftDiameter, rightDiameter) + 1;
+  }
 }

From 2b9239099b1a82e441629f6990460778a932aa35 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Oct 2021 20:55:03 -0500
Subject: [PATCH 0603/2175] Update Guess Number Higher or Lower.java

---
 Easy/Guess Number Higher or Lower.java | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/Easy/Guess Number Higher or Lower.java b/Easy/Guess Number Higher or Lower.java
index e10f90ab..91b9aeb0 100644
--- a/Easy/Guess Number Higher or Lower.java	
+++ b/Easy/Guess Number Higher or Lower.java	
@@ -13,15 +13,13 @@ public int guessNumber(int n) {
     int end = n;
     while (start <= end) {
       int mid = start + (end - start) / 2;
-      int res = guess(mid);
-      if (res == 0) {
-        return mid;
-      }
-      else if (res == -1) {
+      int result = guess(mid);
+      if (result == -1) {
         end = mid - 1;
-      }
-      else {
+      } else if (result == 1) {
         start = mid + 1;
+      } else {
+        return mid;
       }
     }
     return -1;

From 4645f741c32640681af46d58f666463e42c365aa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Oct 2021 08:43:17 -0500
Subject: [PATCH 0604/2175] Update Construct Binary Search Tree from Preorder
 Traversal.java

---
 ...y Search Tree from Preorder Traversal.java | 28 +++++++++++--------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/Medium/Construct Binary Search Tree from Preorder Traversal.java b/Medium/Construct Binary Search Tree from Preorder Traversal.java
index 9361c50c..36407655 100644
--- a/Medium/Construct Binary Search Tree from Preorder Traversal.java	
+++ b/Medium/Construct Binary Search Tree from Preorder Traversal.java	
@@ -4,25 +4,29 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  int idx;
   public TreeNode bstFromPreorder(int[] preorder) {
-    idx = 0;
-    return helper(preorder, Integer.MIN_VALUE, Integer.MAX_VALUE);
+    int[] idx = {0};
+    return formBST(preorder, Integer.MIN_VALUE, Integer.MAX_VALUE, idx);
   }
   
-  private TreeNode helper(int[] preorder, int lower, int upper) {
-    if (idx == preorder.length || preorder[idx] < lower || preorder[idx] > upper) {
+  private TreeNode formBST(int[] preorder, int min, int max, int[] idx) {
+    if (idx[0] == preorder.length || preorder[idx[0]] < min || preorder[idx[0]] > max) {
       return null;
     }
-    int val = preorder[idx];
-    idx++;
-    TreeNode root = new TreeNode(val);
-    root.left = helper(preorder, lower, val);
-    root.right = helper(preorder, val, upper);
-    return root;
+    int val = preorder[idx[0]++];
+    TreeNode node = new TreeNode(val);
+    node.left = formBST(preorder, min, val, idx);
+    node.right = formBST(preorder, val, max, idx);
+    return node;
   }
 }

From 515e7af20930911810cc9600599cf46e55193aa2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Oct 2021 09:25:39 -0500
Subject: [PATCH 0605/2175] Update Perfect Squares.java

---
 Medium/Perfect Squares.java | 31 +++++++++----------------------
 1 file changed, 9 insertions(+), 22 deletions(-)

diff --git a/Medium/Perfect Squares.java b/Medium/Perfect Squares.java
index f0b9fb81..4f61d351 100644
--- a/Medium/Perfect Squares.java	
+++ b/Medium/Perfect Squares.java	
@@ -1,28 +1,15 @@
 class Solution {
-  Set<Integer> squareNums;
   public int numSquares(int n) {
-    squareNums = new HashSet<>();
-    for (int i = 1; i * i <= n; i++) {
-      squareNums.add(i * i);
-    }
-    int count = 1;
-    for (count = 1; count <= n; count++) {
-      if (isDividedBy(n, count)) {
-        return count;
-      }
-    }
-    return count;
-  }
-  
-  private boolean isDividedBy(int n, int count) {
-    if (count == 1) {
-      return squareNums.contains(n);
-    }
-    for (Integer squareNum : squareNums) {
-      if (isDividedBy(n - squareNum, count - 1)) {
-        return true;
+    int[] dp = new int[n + 1];
+    Arrays.fill(dp, Integer.MAX_VALUE);
+    dp[0] = 0;
+    for(int i = 1; i <= n; i++) {
+      int min = Integer.MAX_VALUE;
+      for (int j = 1; i - j * j >= 0; j++) {
+        min = Math.min(min, dp[i - j * j] + 1);
       }
+      dp[i] = min;
     }
-    return false;
+    return dp[n];
   }
 }

From a0f7fcda4654de22b0be01954cfbdc8f307c80cd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Oct 2021 07:55:01 -0500
Subject: [PATCH 0606/2175] Create Binary Watch.java

---
 Easy/Binary Watch.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Binary Watch.java

diff --git a/Easy/Binary Watch.java b/Easy/Binary Watch.java
new file mode 100644
index 00000000..454f9b6c
--- /dev/null
+++ b/Easy/Binary Watch.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public List<String> readBinaryWatch(int turnedOn) {
+    return IntStream.range(0, 12)
+        .boxed()
+        .flatMap(
+            h -> IntStream.range(0, 60)
+                .boxed()
+                .filter(s -> Integer.bitCount(h) + Integer.bitCount(s) == turnedOn)
+                .map(m -> String.format("%d:%02d", h, m))
+        )
+        .collect(Collectors.toList());
+  }
+}

From 043a5f8647fb49954349c920115a0c04f7583a2d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Oct 2021 13:42:03 -0500
Subject: [PATCH 0607/2175] Create Minimum Number of Moves to Seat
 Everyone.java

---
 Easy/Minimum Number of Moves to Seat Everyone.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Minimum Number of Moves to Seat Everyone.java

diff --git a/Easy/Minimum Number of Moves to Seat Everyone.java b/Easy/Minimum Number of Moves to Seat Everyone.java
new file mode 100644
index 00000000..be3f18c1
--- /dev/null
+++ b/Easy/Minimum Number of Moves to Seat Everyone.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int minMovesToSeat(int[] seats, int[] students) {
+    Arrays.sort(seats);
+    Arrays.sort(students);
+    int moves = 0;
+    for (int i = 0; i < seats.length; i++) {
+      moves += Math.abs(seats[i] - students[i]);
+    }
+    return moves;
+  }
+}

From a32a1242bff64b38ef4b3e8c7d07e37f58a3e5d2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Oct 2021 08:44:58 -0500
Subject: [PATCH 0608/2175] Create Check if Numbers Are Ascending in a
 Sentence.java

---
 ...f Numbers Are Ascending in a Sentence.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Check if Numbers Are Ascending in a Sentence.java

diff --git a/Easy/Check if Numbers Are Ascending in a Sentence.java b/Easy/Check if Numbers Are Ascending in a Sentence.java
new file mode 100644
index 00000000..b7f5ac65
--- /dev/null
+++ b/Easy/Check if Numbers Are Ascending in a Sentence.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public boolean areNumbersAscending(String s) {
+    int prevValue = Integer.MIN_VALUE;
+    for (int i = 0; i < s.length(); ) {
+      if (Character.isDigit(s.charAt(i))) {
+        int currNum = 0;
+        while (i < s.length() && Character.isDigit(s.charAt(i))) {
+          currNum = currNum * 10 + Character.getNumericValue(s.charAt(i++));
+        }
+        if (currNum <= prevValue) {
+          return false;
+        }
+        prevValue = currNum;
+      }
+      i++;
+    }
+    return true;
+  }
+}

From 96a599fc14e32c89a603bee2035e5472843cb430 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Oct 2021 20:53:33 -0500
Subject: [PATCH 0609/2175] Create Simple Bank System.java

---
 Medium/Simple Bank System.java | 44 ++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 Medium/Simple Bank System.java

diff --git a/Medium/Simple Bank System.java b/Medium/Simple Bank System.java
new file mode 100644
index 00000000..a674aa0f
--- /dev/null
+++ b/Medium/Simple Bank System.java	
@@ -0,0 +1,44 @@
+class Bank {
+
+  private long[] balance;
+  public Bank(long[] balance) {
+    this.balance = balance;
+  }
+
+  public boolean transfer(int account1, int account2, long money) {
+    if (isInvalidAccount(account1) || isInvalidAccount(account2) || balance[account1 - 1] < money) {
+      return false;
+    }
+    balance[account1 - 1] -= money;
+    balance[account2 - 1] += money;
+    return true;
+  }
+
+  public boolean deposit(int account, long money) {
+    if (isInvalidAccount(account)) {
+      return false;
+    }
+    balance[account - 1] += money;
+    return true;
+  }
+
+  public boolean withdraw(int account, long money) {
+    if (isInvalidAccount(account) || balance[account - 1] < money) {
+      return false;
+    }
+    balance[account - 1] -= money;
+    return true;
+  }
+
+  private boolean isInvalidAccount(int accountId) {
+    return !(accountId >= 1 && accountId <= this.balance.length);
+  }
+}
+
+/**
+ * Your Bank object will be instantiated and called as such:
+ * Bank obj = new Bank(balance);
+ * boolean param_1 = obj.transfer(account1,account2,money);
+ * boolean param_2 = obj.deposit(account,money);
+ * boolean param_3 = obj.withdraw(account,money);
+ */

From a5b5c5aed2a1d96bbbdf01bb60e06ea2accf2ef8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Oct 2021 21:05:11 -0500
Subject: [PATCH 0610/2175] Update Cousins in Binary Tree.java

---
 Easy/Cousins in Binary Tree.java | 37 ++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/Easy/Cousins in Binary Tree.java b/Easy/Cousins in Binary Tree.java
index 21c6431d..6d76a140 100644
--- a/Easy/Cousins in Binary Tree.java	
+++ b/Easy/Cousins in Binary Tree.java	
@@ -15,27 +15,32 @@
  */
 class Solution {
   public boolean isCousins(TreeNode root, int x, int y) {
-    int[] depthAndParentX = {0, 0};
-    int[] depthAndParentY = {0, 0};
-    helper(root, x, 0, null, depthAndParentX);
-    helper(root, y, 0, null, depthAndParentY);
-    return depthAndParentX[0] == depthAndParentY[0] && depthAndParentX[1] != depthAndParentY[1];
+    NodeDetail nodeDetailX = getNodeDetail(root, x, null, 0);
+    NodeDetail nodeDetailY = getNodeDetail(root, y, null, 0);
+    return nodeDetailX.depth == nodeDetailY.depth && nodeDetailX.parent != nodeDetailY.parent;
   }
   
-  private void helper(
-    TreeNode root, int num, int currDepth, TreeNode currParent, int[] depthAndParent
-  ) {
+  private NodeDetail getNodeDetail(TreeNode root, int n, TreeNode parent, int depth) {
     if (root == null) {
-      return;
+      return null;
     }
-    if (root.val == num) {
-      System.out.println(root.val + " " + num + " " + (currParent == null ? -1 : currParent.val));
-      depthAndParent[0] = currDepth;
-      depthAndParent[1] = currParent == null ? -1 : currParent.val;
+    if (root.val == n) {
+      return new NodeDetail(parent, depth);
     }
-    else {
-      helper(root.left, num, currDepth + 1, root, depthAndParent);
-      helper(root.right, num, currDepth + 1, root, depthAndParent);
+    NodeDetail left = getNodeDetail(root.left, n, root, depth + 1);
+    if (left != null) {
+      return left;
+    }
+    return getNodeDetail(root.right, n, root, depth + 1);
+  }
+  
+  private class NodeDetail {
+    TreeNode parent;
+    int depth;
+
+    public NodeDetail(TreeNode parent, int depth) {
+      this.parent = parent;
+      this.depth = depth;
     }
   }
 }

From e2dae4541ae7d46e2cd6effacaea1083a7cedfbc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 21 Oct 2021 19:45:08 -0700
Subject: [PATCH 0611/2175] Update Sort Characters By Frequency.java

---
 Medium/Sort Characters By Frequency.java | 41 ++++++++++++++++++------
 1 file changed, 31 insertions(+), 10 deletions(-)

diff --git a/Medium/Sort Characters By Frequency.java b/Medium/Sort Characters By Frequency.java
index 4d0ed2b2..d85dc32a 100644
--- a/Medium/Sort Characters By Frequency.java	
+++ b/Medium/Sort Characters By Frequency.java	
@@ -1,20 +1,41 @@
 class Solution {
   public String frequencySort(String s) {
-    Map<Character, Integer> map = new HashMap<>();
+    int[] freqMap = new int[62];
+    int maxFrequency = 0;
     for (char c : s.toCharArray()) {
-      map.put(c, map.getOrDefault(c, 0) + 1);
+      int charIdx = getCharIndex(c);
+      freqMap[charIdx]++;
+      maxFrequency = Math.max(maxFrequency, freqMap[charIdx]);
+    }
+    List<Character>[] revMap = new List[maxFrequency + 1];
+    for (int i = 0; i < 62; i++) {
+      char c = getDecodedChar(i);
+      int currFreq = freqMap[i];
+      if (currFreq != 0) {
+        if (revMap[currFreq] == null) {
+          revMap[currFreq] = new ArrayList<>();
+        }
+        revMap[currFreq].add(c);
+      }
     }
-    PriorityQueue<Character> pq = new PriorityQueue<>((o1, o2) -> map.get(o2) - map.get(o1));
-    pq.addAll(map.keySet());
     StringBuilder sb = new StringBuilder();
-    while (!pq.isEmpty()) {
-      char c = pq.poll();
-      int count  = map.get(c);
-      while (count-- > 0) {
-        sb.append(c);
+    for (int i = maxFrequency; i > 0; i--) {
+      if (revMap[i] != null) {
+        List<Character> characterList = revMap[i];
+        for (char c : characterList) {
+          sb.append(String.valueOf(c).repeat(i));
+        }
       }
     }
     return sb.toString();
   }
-}
 
+  private char getDecodedChar(int idx) {
+    return (char) (idx < 26 ? 97 + idx : (idx >= 52 ? 48 + idx - 52 : 65 + idx - 26));
+  }
+
+  private int getCharIndex(char c) {
+    return Character.isDigit(c) ? 52 + c - '0'
+        : (Character.isUpperCase(c) ? c - 'A' + 26 : c - 'a');
+  }
+}

From 20ab1882fb87e79762a3bf33e72bc9870947f33a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Oct 2021 09:24:48 -0700
Subject: [PATCH 0612/2175] Update Next Greater Element I.java

---
 Easy/Next Greater Element I.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Easy/Next Greater Element I.java b/Easy/Next Greater Element I.java
index 8b7e88d1..8deb6de6 100644
--- a/Easy/Next Greater Element I.java	
+++ b/Easy/Next Greater Element I.java	
@@ -1,20 +1,20 @@
 class Solution {
   public int[] nextGreaterElement(int[] nums1, int[] nums2) {
     Stack<Integer> stack = new Stack<>();
-    int[] greater = new int[nums2.length];
-    Map<Integer, Integer> map = new HashMap<>();
+    int[] nextMaximum = new int[nums2.length];
+    Map<Integer, Integer> indexMap = new HashMap<>();
     for (int i = nums2.length - 1; i >= 0; i--) {
-      while (!stack.isEmpty() && stack.peek() < nums2[i]) {
+      while (!stack.isEmpty() && stack.peek() <= nums2[i]) {
         stack.pop();
       }
-      greater[i] = stack.isEmpty() ? -1 : stack.peek();
-      map.put(nums2[i], i);
+      nextMaximum[i] = stack.isEmpty() ? -1 : stack.peek();
       stack.push(nums2[i]);
+      indexMap.put(nums2[i], i);
     }
-    int[] ans = new int[nums1.length];
+    int[] nextMaximumResult = new int[nums1.length];
     for (int i = 0; i < nums1.length; i++) {
-      ans[i] = greater[map.get(nums1[i])];
+      nextMaximumResult[i] = nextMaximum[indexMap.get(nums1[i])];
     }
-    return ans;
+    return nextMaximumResult;
   }
 }

From 068f0c8dd17e38cd7aafc214fb7d96c0fd46a2e3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Oct 2021 21:30:42 -0700
Subject: [PATCH 0613/2175] Create Number of Valid Words in a Sentence.java

---
 Easy/Number of Valid Words in a Sentence.java | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 Easy/Number of Valid Words in a Sentence.java

diff --git a/Easy/Number of Valid Words in a Sentence.java b/Easy/Number of Valid Words in a Sentence.java
new file mode 100644
index 00000000..686add3b
--- /dev/null
+++ b/Easy/Number of Valid Words in a Sentence.java	
@@ -0,0 +1,35 @@
+class Solution {
+  
+  public int countValidWords(String sentence) {
+    return (int) Arrays.stream(sentence.split("\\s+")).filter(Solution::isValidWord).count();
+  }
+
+  public static boolean isValidWord(String s) {
+    if (s.isEmpty()
+        || s.charAt(0) == '-'
+        || s.charAt(s.length() - 1) == '-'
+        || (s.length() > 1 && !Character.isLetter(s.charAt(0)))) {
+      return false;
+    }
+    boolean punctuationFound = false;
+    boolean hyphenFound = false;
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (Character.isDigit(c)) {
+        return false;
+      }
+      if (c == '-') {
+        if (hyphenFound || !(Character.isLetter(s.charAt(i - 1)) && Character.isLetter(s.charAt(i + 1)))) {
+          return false;
+        }
+        hyphenFound = true;
+      } else if (!Character.isLetter(c)) {
+          if (punctuationFound || i != s.length() - 1) {
+            return false;
+          }
+          punctuationFound = true;
+      }
+    }
+    return true;
+  }
+}

From 42cfbdfe7514296c74ed2f7ba1ec9a5fe0b4de19 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 25 Oct 2021 08:26:23 -0700
Subject: [PATCH 0614/2175] Create Next Greater Numerically Balanced
 Number.java

---
 Medium/Next Greater Numerically Balanced Number.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Medium/Next Greater Numerically Balanced Number.java

diff --git a/Medium/Next Greater Numerically Balanced Number.java b/Medium/Next Greater Numerically Balanced Number.java
new file mode 100644
index 00000000..c5b399c5
--- /dev/null
+++ b/Medium/Next Greater Numerically Balanced Number.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public final int[] CANDIDATES = new int[] {1, 22, 122, 212, 221, 333, 1333, 3133, 3313, 3331, 4444, 14444, 22333, 23233, 23323, 23332, 32233, 32323, 32332, 33223, 33232, 33322, 41444, 44144, 44414, 44441, 55555, 122333, 123233, 123323, 123332, 132233, 132323, 132332, 133223, 133232, 133322, 155555, 212333, 213233, 213323, 213332, 221333, 223133, 223313, 223331, 224444, 231233, 231323, 231332, 232133, 232313, 232331, 233123, 233132, 233213, 233231, 233312, 233321, 242444, 244244, 244424, 244442, 312233, 312323, 312332, 313223, 313232, 313322, 321233, 321323, 321332, 322133, 322313, 322331, 323123, 323132, 323213, 323231, 323312, 323321, 331223, 331232, 331322, 332123, 332132, 332213, 332231, 332312, 332321, 333122, 333212, 333221, 422444, 424244, 424424, 424442, 442244, 442424, 442442, 444224, 444242, 444422, 515555, 551555, 555155, 555515, 555551, 666666};
+  public int nextBeautifulNumber(int n) {
+    return Arrays.stream(CANDIDATES).filter(candidate -> candidate > n).findFirst().orElse(1224444);
+  }
+}

From d9ca92864b2d070805fcf06778da1df54fe8e802 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Oct 2021 17:28:21 -0700
Subject: [PATCH 0615/2175] Update Sort Colors.java

---
 Medium/Sort Colors.java | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/Medium/Sort Colors.java b/Medium/Sort Colors.java
index 6fc66d88..1bbb3b95 100644
--- a/Medium/Sort Colors.java	
+++ b/Medium/Sort Colors.java	
@@ -1,25 +1,22 @@
 class Solution {
   public void sortColors(int[] nums) {
     int zeroIdx = 0;
-    int curr = 0;
-    int n = nums.length - 1;
-    int twoIdx = n;
-    while (curr <= twoIdx) {
-      if (nums[curr] == 0) {
-        swap(nums, curr++, zeroIdx++);
-      }
-      else if (nums[curr] == 2) {
-        swap(nums, curr, twoIdx--);
-      }
-      else {
-        curr++;
+    int twoIdx = nums.length - 1;
+    int currIdx = 0;
+    while (currIdx <= twoIdx) {
+      if (nums[currIdx] == 0) {
+        swap(nums, currIdx++, zeroIdx++);
+      } else if (nums[currIdx] == 2) {
+        swap(nums, currIdx, twoIdx--);
+      } else {
+        currIdx++;
       }
     }
   }
   
-  private void swap(int[] nums, int idx1, int idx2) {
-    int temp = nums[idx1];
-    nums[idx1] = nums[idx2];
-    nums[idx2] = temp;
+  private void swap(int[] nums, int idxOne, int idxTwo) {
+    int temp = nums[idxTwo];
+    nums[idxTwo] = nums[idxOne];
+    nums[idxOne] = temp;
   }
 }

From b6225779819f5db85f56cb63004a025b130d05ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Oct 2021 20:04:44 -0700
Subject: [PATCH 0616/2175] Update Rotting Oranges.java

---
 Medium/Rotting Oranges.java | 52 +++++++++++++++++++------------------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/Medium/Rotting Oranges.java b/Medium/Rotting Oranges.java
index a4eb051f..39ea7886 100644
--- a/Medium/Rotting Oranges.java	
+++ b/Medium/Rotting Oranges.java	
@@ -1,39 +1,41 @@
 class Solution {
-  int[][] dirs = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
-  public final int VISITED = -1;
+  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
   public int orangesRotting(int[][] grid) {
-    int minutes = 0;
-    Queue<int[]> queue = new LinkedList<>();
+    Queue<int[]> infectedOranges = new LinkedList<>();
+    int numOfFreshOranges = 0;
     for (int i = 0; i < grid.length; i++) {
       for (int j = 0; j < grid[i].length; j++) {
         if (grid[i][j] == 2) {
-          queue.add(new int[]{i, j});
+          infectedOranges.add(new int[]{i, j});
         }
+        numOfFreshOranges += grid[i][j] == 1 ? 1 : 0;
       }
     }
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        for (int[] dir : dirs) {
-          int newX = removed[0] + dir[0];
-          int newY = removed[1] + dir[1];
-          if (newX >= 0 && newX < grid.length && newY >= 0 && newY < grid[0].length && grid[newX][newY] == 1) {
-            grid[newX][newY] = 2;
-            queue.add(new int[]{newX, newY});
+    int numOfMinutes = 0;
+    while (!infectedOranges.isEmpty()) {
+      int infectedOrangeSize = infectedOranges.size();
+      boolean newInfected = false;
+      while (infectedOrangeSize-- > 0) {
+        int[] infectedOrangeCoordinate = infectedOranges.poll();
+        for (int[] dir : DIRS) {
+          int newRowCoordinate = infectedOrangeCoordinate[0] + dir[0];
+          int newColCoordinate = infectedOrangeCoordinate[1] + dir[1];
+          if (isValidInfection(grid, newRowCoordinate, newColCoordinate)) {
+            infectedOranges.add(new int[]{newRowCoordinate, newColCoordinate});
+            grid[newRowCoordinate][newColCoordinate] = 2;
+            newInfected = true;
+            numOfFreshOranges--;
           }
         }
-        grid[removed[0]][removed[1]] = VISITED;
       }
-      minutes++;
+      numOfMinutes += newInfected ? 1 : 0;
     }
-    for (int i = 0; i < grid.length; i++) {
-      for (int j = 0; j < grid[i].length; j++) {
-        if (grid[i][j] == 1) {
-          return -1;
-        }
-      }
-    }
-    return minutes > 0 ? minutes - 1 : 0;
+    return numOfFreshOranges > 0 ? -1 : numOfMinutes;
+  }
+
+  private boolean isValidInfection(int[][] grid, int rowCoordinate, int colCoordinate) {
+    return rowCoordinate >= 0 && colCoordinate >= 0 && rowCoordinate < grid.length
+        && colCoordinate < grid[0].length && grid[rowCoordinate][colCoordinate] == 1;
   }
 }

From fe169cf9d706cf4473f30de8c31afbb3dd8e7bd5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Oct 2021 11:43:49 -0700
Subject: [PATCH 0617/2175] Create Kth Distinct String in an Array.java

---
 Easy/Kth Distinct String in an Array.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Kth Distinct String in an Array.java

diff --git a/Easy/Kth Distinct String in an Array.java b/Easy/Kth Distinct String in an Array.java
new file mode 100644
index 00000000..31a474f7
--- /dev/null
+++ b/Easy/Kth Distinct String in an Array.java	
@@ -0,0 +1,11 @@
+import java.util.Map.Entry;
+
+class Solution {
+  public String kthDistinct(String[] arr, int k) {
+    return Arrays.stream(arr).collect(
+            Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()))
+        .entrySet().stream().filter(entry -> entry.getValue().equals(1L)).map(Entry::getKey)
+        .skip(k - 1)
+        .findFirst().orElse("");
+  }
+}

From 846b482aacd53558d5c6b3cdb8c0925c17e4e307 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Oct 2021 23:07:27 -0700
Subject: [PATCH 0618/2175] Create Smallest Index With Equal Value.java

---
 Easy/Smallest Index With Equal Value.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Smallest Index With Equal Value.java

diff --git a/Easy/Smallest Index With Equal Value.java b/Easy/Smallest Index With Equal Value.java
new file mode 100644
index 00000000..1c6d2ea3
--- /dev/null
+++ b/Easy/Smallest Index With Equal Value.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public int smallestEqual(int[] nums) {
+    return IntStream.range(0, nums.length).filter(i -> i % 10 == nums[i]).findFirst().orElse(-1);
+  }
+}

From cbd9820aa35b7f349f8a5cb177893b0c39b43484 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Oct 2021 12:34:31 -0700
Subject: [PATCH 0619/2175] Create Find the Minimum and Maximum Number of Nodes
 Between Critical Points.java

---
 ...mber of Nodes Between Critical Points.java | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Find the Minimum and Maximum Number of Nodes Between Critical Points.java

diff --git a/Medium/Find the Minimum and Maximum Number of Nodes Between Critical Points.java b/Medium/Find the Minimum and Maximum Number of Nodes Between Critical Points.java
new file mode 100644
index 00000000..dfab1434
--- /dev/null
+++ b/Medium/Find the Minimum and Maximum Number of Nodes Between Critical Points.java	
@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public int[] nodesBetweenCriticalPoints(ListNode head) {
+    int firstIdx = Integer.MAX_VALUE;
+    int lastIdx = 0;
+    int minDistance = Integer.MAX_VALUE;
+    int prevVal = head.val;
+    for (int i = 0; head.next != null; i++) {
+      if ((prevVal < head.val && head.next.val < head.val) ||
+          (prevVal > head.val && head.next.val > head.val)) {
+        if (lastIdx != 0) {
+          minDistance = Math.min(minDistance, i - lastIdx);
+        }
+        firstIdx = Math.min(firstIdx, i);
+        lastIdx = i;
+      }
+      prevVal = head.val;
+      head = head.next;
+    }
+    return minDistance == Integer.MAX_VALUE ? new int[]{-1, -1} : new int[]{minDistance, lastIdx - firstIdx};
+  }
+}

From 04b7792ad3745eae16ed14a6666a37d242d5df52 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 3 Nov 2021 12:48:30 -0700
Subject: [PATCH 0620/2175] Update Assign Cookies.java

---
 Easy/Assign Cookies.java | 25 +++++++++++--------------
 1 file changed, 11 insertions(+), 14 deletions(-)

diff --git a/Easy/Assign Cookies.java b/Easy/Assign Cookies.java
index 164c2bfe..f6a91ecd 100644
--- a/Easy/Assign Cookies.java	
+++ b/Easy/Assign Cookies.java	
@@ -1,17 +1,14 @@
 class Solution {
-    public int findContentChildren(int[] g, int[] s) {
-        Arrays.sort(g);
-        Arrays.sort(s);
-        int count = 0;
-        for (int i=0;i<g.length;i++) {
-            for (int j=0;j<s.length;j++) {
-                if (g[i] <= s[j]) {
-                    s[j] = 0;
-                    count++;
-                    break;
-                }
-            }
-        }
-        return count;
+  public int findContentChildren(int[] g, int[] s) {
+    Arrays.sort(g);
+    Arrays.sort(s);
+    int contentChildrenCount = 0;
+    for (int i = 0, j = 0; i < s.length && j < g.length; i++) {
+      if (s[i] >= g[j]) {
+        contentChildrenCount++;
+        j++;
+      }
     }
+    return contentChildrenCount;
+  }
 }

From 4f0cefe3a1697ed0a7aa6ad234e4ed08e7e6491f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Nov 2021 17:40:02 -0700
Subject: [PATCH 0621/2175] Update Arranging Coins.java

---
 Easy/Arranging Coins.java | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/Easy/Arranging Coins.java b/Easy/Arranging Coins.java
index bf2f70fa..0719ca73 100644
--- a/Easy/Arranging Coins.java	
+++ b/Easy/Arranging Coins.java	
@@ -1,14 +1,18 @@
 class Solution {
   public int arrangeCoins(int n) {
-    int copy = n;
-    int count = 0;
-    for (int i = 1; i <= copy && n > 0; i++) {
-      n -= i;
-      if (n < 0) {
-        break;
+    long left = 1;
+    long right = n;
+    while (left <= right) {
+      long mid = (left + right) / 2;
+      long sum = mid * (mid + 1) / 2;
+      if (sum == n) {
+        return (int) mid;
+      } else if (sum > n) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
       }
-      count++;
     }
-    return count;
+    return (int) right;
   }
 }

From d180b8001c61bf3b3f914c9beb18a0524e05f7ce Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 5 Nov 2021 17:16:40 -0700
Subject: [PATCH 0622/2175] Update Single Number III.java

---
 Medium/Single Number III.java | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/Medium/Single Number III.java b/Medium/Single Number III.java
index 7caf6b85..0409a84a 100644
--- a/Medium/Single Number III.java	
+++ b/Medium/Single Number III.java	
@@ -1,15 +1,17 @@
 class Solution {
   public int[] singleNumber(int[] nums) {
-    Set<Integer> set = new HashSet<>();
+    int xorValue = Integer.highestOneBit(Arrays.stream(nums)
+        .boxed()
+        .reduce((a, b) -> a ^ b)
+        .orElse(0));
+    int[] result = new int[2];
     for (int num : nums) {
-      if (set.contains(num)) {
-        set.remove(num);
-      }
-      else {
-        set.add(num);
+      if ((xorValue & num) == 0) {
+        result[0] ^= num;
+      } else {
+        result[1] ^= num;
       }
     }
-    Iterator<Integer> iter = set.iterator();
-    return new int[]{iter.next(), iter.next()};
+    return result;
   }
 }

From cca4b898c65c6fae4831a332fc4cbdf300766a17 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Nov 2021 03:11:49 -0800
Subject: [PATCH 0623/2175] Create Count Vowel Substrings of a String.java

---
 Easy/Count Vowel Substrings of a String.java | 32 ++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Easy/Count Vowel Substrings of a String.java

diff --git a/Easy/Count Vowel Substrings of a String.java b/Easy/Count Vowel Substrings of a String.java
new file mode 100644
index 00000000..93ddc212
--- /dev/null
+++ b/Easy/Count Vowel Substrings of a String.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public int countVowelSubstrings(String word) {
+    return atMostVowel(word, 5) - atMostVowel(word, 4);
+  }
+
+  private int atMostVowel(String word, int atMostGoal) {
+    int start = 0;
+    int count = 0;
+    int n = word.length();
+    Map<Character, Integer> map = new HashMap<>();
+    for (int end = 0; end < n; end++) {
+      if (!isVowel(word.charAt(end))) {
+        map.clear();
+        start = end + 1;
+      } else {
+        map.put(word.charAt(end), map.getOrDefault(word.charAt(end), 0) + 1);
+        for (; map.size() > atMostGoal; start++) {
+          map.put(word.charAt(start), map.get(word.charAt(start)) - 1);
+          if (map.get(word.charAt(start)) == 0) {
+            map.remove(word.charAt(start));
+          }
+        }
+        count += end - start + 1;
+      }
+    }
+    return count;
+  }
+  
+  private boolean isVowel(char c) {
+    return "aeiou".indexOf(c) != -1;
+  }
+}

From 494198f8f2c41c9190b6b4f3d7f341e75071ad99 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Nov 2021 03:25:25 -0800
Subject: [PATCH 0624/2175] Update Multiply Strings.java

---
 Medium/Multiply Strings.java | 40 +++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 21 deletions(-)

diff --git a/Medium/Multiply Strings.java b/Medium/Multiply Strings.java
index 9469b6cd..fed474ad 100644
--- a/Medium/Multiply Strings.java	
+++ b/Medium/Multiply Strings.java	
@@ -1,35 +1,33 @@
 class Solution {
-  public String multiply(String num1, String num2) {
-    int m = num1.length();
-    int n = num2.length();
-    int[] ans = new int[m + n];
-    int idx = ans.length - 1;
+    public String multiply(String num1, String num2) {
+    int[] result = new int[num1.length() + num2.length() + 1];
+    int idx = result.length - 1;
     for (int i = num1.length() - 1; i >= 0; i--) {
       int currIdx = idx;
       int carry = 0;
       for (int j = num2.length() - 1; j >= 0; j--) {
-        int temp = (
-          ans[currIdx] + Character.getNumericValue(num1.charAt(i)) * Character.getNumericValue(num2.charAt(j)) + carry
-        );
-        carry = temp > 9 ? temp / 10 : 0;
-        temp = temp > 9 ? temp % 10 : temp;
-        ans[currIdx--] = temp;
+        int currValue =
+            carry + Character.getNumericValue(num1.charAt(i)) * Character.getNumericValue(
+                num2.charAt(j)) + result[currIdx];
+        carry = currValue / 10;
+        currValue = currValue % 10;
+        result[currIdx--] = currValue;
       }
       while (carry > 0) {
-        int temp = ans[currIdx] + carry;
-        carry = temp > 9 ? temp / 10 : 0;
-        temp = temp > 9 ? temp % 10 : temp;
-        ans[currIdx--] = temp;
+        int currValue = carry + result[currIdx];
+        carry = currValue / 10;
+        currValue = currValue % 10;
+        result[currIdx--] = currValue;
       }
       idx--;
     }
-    int zeroIdx = 0;
-    while (zeroIdx < ans.length && ans[zeroIdx] == 0) {
-      zeroIdx++;
-    }
     StringBuilder sb = new StringBuilder();
-    while (zeroIdx < ans.length) {
-      sb.append(ans[zeroIdx++]);
+    int resultIdx = 0;
+    while (resultIdx < result.length && result[resultIdx] == 0) {
+      resultIdx++;
+    }
+    while (resultIdx < result.length) {
+      sb.append(result[resultIdx++]);
     }
     return sb.length() == 0 ? "0" : sb.toString();
   }

From 537c3fb0ff59910bc191901201c80989e5119587 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Nov 2021 19:40:28 -0800
Subject: [PATCH 0625/2175] Create Vowels of All Substrings.java

---
 Medium/Vowels of All Substrings.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Vowels of All Substrings.java

diff --git a/Medium/Vowels of All Substrings.java b/Medium/Vowels of All Substrings.java
new file mode 100644
index 00000000..c54486eb
--- /dev/null
+++ b/Medium/Vowels of All Substrings.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public long countVowels(String word) {
+    long sum = 0;
+    long n = word.length();
+    for (int i = 0; i < n; i++) {
+      if ("aeiou".indexOf(word.charAt(i)) != -1) {
+        sum += (i + 1) * (n - i);
+      }
+    }
+    return sum;
+  }
+}

From 74cf0f4e57f1db20e7042710d08429ffbb724c32 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Nov 2021 16:55:51 -0800
Subject: [PATCH 0626/2175] Update and rename Easy/Best time to buy & sell a
 stock II.java to Medium/Best Time to Buy and Sell Stock II.java

---
 Easy/Best time to buy & sell a stock II.java   | 16 ----------------
 Medium/Best Time to Buy and Sell Stock II.java | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 16 deletions(-)
 delete mode 100644 Easy/Best time to buy & sell a stock II.java
 create mode 100644 Medium/Best Time to Buy and Sell Stock II.java

diff --git a/Easy/Best time to buy & sell a stock II.java b/Easy/Best time to buy & sell a stock II.java
deleted file mode 100644
index cfe8e938..00000000
--- a/Easy/Best time to buy & sell a stock II.java	
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution {
-  public int maxProfit(int[] prices) {
-    int lowest = Integer.MAX_VALUE;
-    int profit = 0;
-    for (int i = 0; i < prices.length; i++) {
-      if (prices[i] > lowest) {
-        profit += prices[i] - lowest;
-        lowest = prices[i];
-      }
-      else {
-        lowest = prices[i];
-      }
-    }
-    return profit;
-  }
-}
diff --git a/Medium/Best Time to Buy and Sell Stock II.java b/Medium/Best Time to Buy and Sell Stock II.java
new file mode 100644
index 00000000..675762b3
--- /dev/null
+++ b/Medium/Best Time to Buy and Sell Stock II.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int maxProfit(int[] prices) {
+    int stockBuyPrice = Integer.MAX_VALUE;
+    int profit = 0;
+    for (int i = 0; i < prices.length; i++) {
+      if (prices[i] > stockBuyPrice) {
+        profit += prices[i] - stockBuyPrice;
+        stockBuyPrice = prices[i];
+      } else {
+        stockBuyPrice = prices[i];
+      }
+    }
+    return profit;
+  }
+}

From e44acbf5bf7fc4e2ffdc2b253489cc594688b6f4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Nov 2021 16:56:24 -0800
Subject: [PATCH 0627/2175] Delete Explore directory

---
 .../Best Time to Buy and Sell Stock II.java   |  15 ---
 Explore/Easy/Arrays/Contains Duplicate.java   |  11 --
 .../Arrays/Intersection of Two Arrays II.java |  34 ------
 Explore/Easy/Arrays/Move Zeroes.java          |  15 ---
 Explore/Easy/Arrays/Plus One.java             |  18 ---
 .../Remove Duplicates from Sorted Array.java  |  19 ---
 Explore/Easy/Arrays/Rotate Array.java         |  19 ---
 Explore/Easy/Arrays/Rotate Image.java         |  29 -----
 Explore/Easy/Arrays/Single Number.java        |  10 --
 Explore/Easy/Arrays/Two Sum.java              |  20 ----
 Explore/Easy/Arrays/Valid Sudoku.java         |  28 -----
 Explore/Easy/Design/Min Stack.java            |  42 -------
 Explore/Easy/Design/Shuffle an Array.java     |  40 -------
 .../Best Time to Buy and Sell Stock.java      |  16 ---
 .../Dynamic Programming/Climbing Stairs.java  |  17 ---
 .../Dynamic Programming/House Robber.java     |  12 --
 .../Dynamic Programming/Maximum Subarray.java |  22 ----
 .../Delete Node in a Linked List.java         |  14 ---
 .../Easy/Linked Lists/Linked List Cycle.java  |  26 -----
 .../Linked Lists/Merge Two Sorted Lists.java  |  44 -------
 .../Linked Lists/Palindrome Linked List.java  |  55 ---------
 .../Remove Nth Node From End of List.java     |  38 ------
 .../Linked Lists/Reverse Linked List.java     |  24 ----
 Explore/Easy/Math/Count Primes.java           |  21 ----
 Explore/Easy/Math/Fizz Buzz.java              |  21 ----
 Explore/Easy/Math/Power of Three.java         |  11 --
 Explore/Easy/Math/Roman to Integer.java       |  39 -------
 Explore/Easy/Others/Hamming Distance.java     |   5 -
 Explore/Easy/Others/Missing Number.java       |  11 --
 Explore/Easy/Others/Number of 1 Bits.java     |   6 -
 Explore/Easy/Others/Pascal's Triangle.java    |  23 ----
 Explore/Easy/Others/Reverse Bits.java         |  13 ---
 Explore/Easy/Others/Valid Parantheses.java    |  23 ----
 .../First Bad Version.java                    |  22 ----
 .../Merge Sorted Array.java                   |  20 ----
 Explore/Easy/Strings/Count and Say.java       |  32 -----
 .../First Unique Character in a String.java   |  17 ---
 Explore/Easy/Strings/Implement strStr().java  |   5 -
 .../Easy/Strings/Longest Common Prefix.java   |  15 ---
 Explore/Easy/Strings/Reverse Integer.java     |  18 ---
 Explore/Easy/Strings/Reverse String.java      |   6 -
 Explore/Easy/Strings/String to Integer.java   |  32 -----
 Explore/Easy/Strings/Valid Anagram.java       |  22 ----
 Explore/Easy/Strings/Valid Palindrome.java    |  16 ---
 .../Binary Tree Level Order Traversal.java    |  39 -------
 ...rt Sorted Array to Binary Search Tree.java |  29 -----
 .../Trees/Maximum Depth of Binary Tree.java   |  16 ---
 Explore/Easy/Trees/Symmetric Tree.java        |  31 -----
 .../Trees/Validate Binary Search Tree.java    |  32 -----
 Explore/Medium/Arrays and Strings/3Sum.java   |  34 ------
 .../Arrays and Strings/Group Anagrams.java    |  30 -----
 .../Increasing Triplet Subsequence.java       |  21 ----
 .../Longest Palindromic Substring.java        |  28 -----
 ...ubstring Without Repeating Characters.java |  22 ----
 .../Arrays and Strings/Missing Ranges.java    | 109 ------------------
 .../Arrays and Strings/Set Matrix Zeroes.java |  64 ----------
 .../Medium/Linked Lists/Add Two Numbers.java  |  48 --------
 .../Intersection of Two Linked Lists.java     |  58 ----------
 .../Linked Lists/Odd Even Linked List.java    |  30 -----
 .../Sorting & Searching/Sort Colors.java      |  23 ----
 .../Top K Frequent Elements.java              |  29 -----
 .../Binary Tree Inorder Traversal.java        |  31 -----
 ...ary Tree Zigzag Level Order Traversal.java |  64 ----------
 ...e from Preorder and Inorder Traversal.java |  35 ------
 .../Kth Smallest Element in a BST.java        |  28 -----
 ...ting Next Right Pointers in Each Node.java |  28 -----
 66 files changed, 1775 deletions(-)
 delete mode 100644 Explore/Easy/Arrays/Best Time to Buy and Sell Stock II.java
 delete mode 100644 Explore/Easy/Arrays/Contains Duplicate.java
 delete mode 100644 Explore/Easy/Arrays/Intersection of Two Arrays II.java
 delete mode 100644 Explore/Easy/Arrays/Move Zeroes.java
 delete mode 100644 Explore/Easy/Arrays/Plus One.java
 delete mode 100644 Explore/Easy/Arrays/Remove Duplicates from Sorted Array.java
 delete mode 100644 Explore/Easy/Arrays/Rotate Array.java
 delete mode 100644 Explore/Easy/Arrays/Rotate Image.java
 delete mode 100644 Explore/Easy/Arrays/Single Number.java
 delete mode 100644 Explore/Easy/Arrays/Two Sum.java
 delete mode 100644 Explore/Easy/Arrays/Valid Sudoku.java
 delete mode 100644 Explore/Easy/Design/Min Stack.java
 delete mode 100644 Explore/Easy/Design/Shuffle an Array.java
 delete mode 100644 Explore/Easy/Dynamic Programming/Best Time to Buy and Sell Stock.java
 delete mode 100644 Explore/Easy/Dynamic Programming/Climbing Stairs.java
 delete mode 100644 Explore/Easy/Dynamic Programming/House Robber.java
 delete mode 100644 Explore/Easy/Dynamic Programming/Maximum Subarray.java
 delete mode 100644 Explore/Easy/Linked Lists/Delete Node in a Linked List.java
 delete mode 100644 Explore/Easy/Linked Lists/Linked List Cycle.java
 delete mode 100644 Explore/Easy/Linked Lists/Merge Two Sorted Lists.java
 delete mode 100644 Explore/Easy/Linked Lists/Palindrome Linked List.java
 delete mode 100644 Explore/Easy/Linked Lists/Remove Nth Node From End of List.java
 delete mode 100644 Explore/Easy/Linked Lists/Reverse Linked List.java
 delete mode 100644 Explore/Easy/Math/Count Primes.java
 delete mode 100644 Explore/Easy/Math/Fizz Buzz.java
 delete mode 100644 Explore/Easy/Math/Power of Three.java
 delete mode 100644 Explore/Easy/Math/Roman to Integer.java
 delete mode 100644 Explore/Easy/Others/Hamming Distance.java
 delete mode 100644 Explore/Easy/Others/Missing Number.java
 delete mode 100644 Explore/Easy/Others/Number of 1 Bits.java
 delete mode 100644 Explore/Easy/Others/Pascal's Triangle.java
 delete mode 100644 Explore/Easy/Others/Reverse Bits.java
 delete mode 100644 Explore/Easy/Others/Valid Parantheses.java
 delete mode 100644 Explore/Easy/Sorting and Searching/First Bad Version.java
 delete mode 100644 Explore/Easy/Sorting and Searching/Merge Sorted Array.java
 delete mode 100644 Explore/Easy/Strings/Count and Say.java
 delete mode 100644 Explore/Easy/Strings/First Unique Character in a String.java
 delete mode 100644 Explore/Easy/Strings/Implement strStr().java
 delete mode 100644 Explore/Easy/Strings/Longest Common Prefix.java
 delete mode 100644 Explore/Easy/Strings/Reverse Integer.java
 delete mode 100644 Explore/Easy/Strings/Reverse String.java
 delete mode 100644 Explore/Easy/Strings/String to Integer.java
 delete mode 100644 Explore/Easy/Strings/Valid Anagram.java
 delete mode 100644 Explore/Easy/Strings/Valid Palindrome.java
 delete mode 100644 Explore/Easy/Trees/Binary Tree Level Order Traversal.java
 delete mode 100644 Explore/Easy/Trees/Convert Sorted Array to Binary Search Tree.java
 delete mode 100644 Explore/Easy/Trees/Maximum Depth of Binary Tree.java
 delete mode 100644 Explore/Easy/Trees/Symmetric Tree.java
 delete mode 100644 Explore/Easy/Trees/Validate Binary Search Tree.java
 delete mode 100644 Explore/Medium/Arrays and Strings/3Sum.java
 delete mode 100644 Explore/Medium/Arrays and Strings/Group Anagrams.java
 delete mode 100644 Explore/Medium/Arrays and Strings/Increasing Triplet Subsequence.java
 delete mode 100644 Explore/Medium/Arrays and Strings/Longest Palindromic Substring.java
 delete mode 100644 Explore/Medium/Arrays and Strings/Longest Substring Without Repeating Characters.java
 delete mode 100644 Explore/Medium/Arrays and Strings/Missing Ranges.java
 delete mode 100644 Explore/Medium/Arrays and Strings/Set Matrix Zeroes.java
 delete mode 100644 Explore/Medium/Linked Lists/Add Two Numbers.java
 delete mode 100644 Explore/Medium/Linked Lists/Intersection of Two Linked Lists.java
 delete mode 100644 Explore/Medium/Linked Lists/Odd Even Linked List.java
 delete mode 100644 Explore/Medium/Sorting & Searching/Sort Colors.java
 delete mode 100644 Explore/Medium/Sorting & Searching/Top K Frequent Elements.java
 delete mode 100644 Explore/Medium/Trees and Graphs/Binary Tree Inorder Traversal.java
 delete mode 100644 Explore/Medium/Trees and Graphs/Binary Tree Zigzag Level Order Traversal.java
 delete mode 100644 Explore/Medium/Trees and Graphs/Construct Binary Tree from Preorder and Inorder Traversal.java
 delete mode 100644 Explore/Medium/Trees and Graphs/Kth Smallest Element in a BST.java
 delete mode 100644 Explore/Medium/Trees and Graphs/Populating Next Right Pointers in Each Node.java

diff --git a/Explore/Easy/Arrays/Best Time to Buy and Sell Stock II.java b/Explore/Easy/Arrays/Best Time to Buy and Sell Stock II.java
deleted file mode 100644
index b8ac504e..00000000
--- a/Explore/Easy/Arrays/Best Time to Buy and Sell Stock II.java	
+++ /dev/null
@@ -1,15 +0,0 @@
-class Solution {
-    public int maxProfit(int[] prices) {
-        int profit = 0;
-        
-        for (int i=1;i<prices.length;i++) {
-            int diff = prices[i] - prices[i-1];
-            
-            if (diff > 0) {
-                profit += diff;
-            }
-        }
-        
-        return profit;
-    }
-}
diff --git a/Explore/Easy/Arrays/Contains Duplicate.java b/Explore/Easy/Arrays/Contains Duplicate.java
deleted file mode 100644
index 4268a04d..00000000
--- a/Explore/Easy/Arrays/Contains Duplicate.java	
+++ /dev/null
@@ -1,11 +0,0 @@
-class Solution {
-    public boolean containsDuplicate(int[] nums) {
-        Set<Integer> arr = new HashSet<>();
-        
-        for (int i=0;i<nums.length;i++) {
-            arr.add(nums[i]);
-        }
-        
-        return arr.size() != nums.length;
-    }
-}
diff --git a/Explore/Easy/Arrays/Intersection of Two Arrays II.java b/Explore/Easy/Arrays/Intersection of Two Arrays II.java
deleted file mode 100644
index 9b474194..00000000
--- a/Explore/Easy/Arrays/Intersection of Two Arrays II.java	
+++ /dev/null
@@ -1,34 +0,0 @@
-class Solution {
-    public int[] intersect(int[] nums1, int[] nums2) {
-        Map<Integer, Integer> map1 = new HashMap<>();
-        Map<Integer, Integer> map2 = new HashMap<>();
-        
-        for (int i=0;i<nums1.length;i++) {
-            map1.put(nums1[i], map1.getOrDefault(nums1[i], 0) + 1);
-        }
-        
-        for (int i=0;i<nums2.length;i++) {
-            map2.put(nums2[i], map2.getOrDefault(nums2[i], 0) + 1);
-        }
-        
-        List<Integer> list = new ArrayList<>();
-        
-        for(Map.Entry<Integer, Integer> entry : map1.entrySet()) {
-            if (map2.containsKey(entry.getKey())) {
-                int count = Math.min(entry.getValue(), map2.get(entry.getKey()));
-                while (count > 0) {
-                    list.add(entry.getKey());
-                    count--;
-                }
-            }
-        }
-        
-        int[] ans = new int[list.size()];
-        
-        for (int i=0;i<list.size();i++) {
-            ans[i] = list.get(i);
-        } 
-        
-        return ans;
-    }
-}
diff --git a/Explore/Easy/Arrays/Move Zeroes.java b/Explore/Easy/Arrays/Move Zeroes.java
deleted file mode 100644
index ddb0f134..00000000
--- a/Explore/Easy/Arrays/Move Zeroes.java	
+++ /dev/null
@@ -1,15 +0,0 @@
-class Solution {
-    public void moveZeroes(int[] nums) {
-        int j = 0;
-        
-        for (int i=0;i<nums.length;i++) {
-            if (nums[i] != 0) {
-                nums[j++] = nums[i];
-            }
-        }
-        
-        while (j < nums.length) {
-            nums[j++] = 0;
-        }
-    }
-}
diff --git a/Explore/Easy/Arrays/Plus One.java b/Explore/Easy/Arrays/Plus One.java
deleted file mode 100644
index 1efad487..00000000
--- a/Explore/Easy/Arrays/Plus One.java	
+++ /dev/null
@@ -1,18 +0,0 @@
-class Solution {
-    public int[] plusOne(int[] digits) {
-        
-        for (int i=digits.length-1;i>=0;i--) {
-            if (digits[i] < 9) {
-                digits[i]++;
-                return digits;
-            }
-            
-            digits[i] = 0;
-        }
-        
-        int[] newDigits = new int[digits.length+1];
-        newDigits[0] = 1;
-        
-        return newDigits;
-    }
-}
diff --git a/Explore/Easy/Arrays/Remove Duplicates from Sorted Array.java b/Explore/Easy/Arrays/Remove Duplicates from Sorted Array.java
deleted file mode 100644
index 7f1b92d8..00000000
--- a/Explore/Easy/Arrays/Remove Duplicates from Sorted Array.java	
+++ /dev/null
@@ -1,19 +0,0 @@
-class Solution {
-    public int removeDuplicates(int[] nums) {
-        int n = nums.length;
-        
-        if (n == 0 || n == 1) return n;
-        
-        int j = 0;
-        
-        for (int i=0;i<n-1;i++) {
-            if (nums[i] != nums[i+1]) {
-                nums[j++] = nums[i];
-            }
-        }
-        
-        nums[j++] = nums[n-1];
-        
-        return j;
-    }
-}
diff --git a/Explore/Easy/Arrays/Rotate Array.java b/Explore/Easy/Arrays/Rotate Array.java
deleted file mode 100644
index 2da8a723..00000000
--- a/Explore/Easy/Arrays/Rotate Array.java	
+++ /dev/null
@@ -1,19 +0,0 @@
-class Solution {
-    public void rotate(int[] nums, int k) {
-        k %= nums.length;
-        
-        rotate(nums, 0, nums.length-1);
-        rotate(nums,0,k-1);
-        rotate(nums, k, nums.length-1);
-    }
-    
-    public void rotate(int[] arr, int start, int end) {
-        while(start < end) {
-            int t = arr[start];
-            arr[start] = arr[end];
-            arr[end] =  t;
-            start++;
-            end--;
-        }
-    }
-}
diff --git a/Explore/Easy/Arrays/Rotate Image.java b/Explore/Easy/Arrays/Rotate Image.java
deleted file mode 100644
index c745d2fb..00000000
--- a/Explore/Easy/Arrays/Rotate Image.java	
+++ /dev/null
@@ -1,29 +0,0 @@
-class Solution {
-    public void rotate(int[][] matrix) {
-        reverseUpDown(matrix, matrix.length, matrix[0].length);
-        
-        for (int i=0;i<matrix.length;i++) {
-            for (int j=i+1;j<matrix[0].length;j++) {
-                int temp = matrix[i][j];
-                matrix[i][j] = matrix[j][i];
-                matrix[j][i] = temp;
-            }
-        }
-    }
-    
-    public void reverseUpDown(int[][] matrix, int row, int col) {
-        
-        int i = 0;
-        int j = row-1;
-        
-        while(i<j) {
-            for (int k=0;k<matrix[0].length;k++) {
-                int temp = matrix[i][k];
-                matrix[i][k] = matrix[j][k];
-                matrix[j][k] = temp;
-            }
-            i++;
-            j--;
-        }
-    }
-}
diff --git a/Explore/Easy/Arrays/Single Number.java b/Explore/Easy/Arrays/Single Number.java
deleted file mode 100644
index 1bbcd07c..00000000
--- a/Explore/Easy/Arrays/Single Number.java	
+++ /dev/null
@@ -1,10 +0,0 @@
-ass Solution {
-    public int singleNumber(int[] nums) {
-        int num = 0;
-        for (int i=0;i<nums.length;i++) {
-            num = num^nums[i];
-        }
-        
-        return num;
-    }
-}
diff --git a/Explore/Easy/Arrays/Two Sum.java b/Explore/Easy/Arrays/Two Sum.java
deleted file mode 100644
index 17dc4126..00000000
--- a/Explore/Easy/Arrays/Two Sum.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-    public int[] twoSum(int[] nums, int target) {
-        Map<Integer, Integer> map = new HashMap<>();
-        int[] ans = new int[2];
-        
-        for (int i=0;i<nums.length;i++) {
-            map.put(nums[i], i);
-        }
-        
-        for (int i=0;i<nums.length;i++) {
-            if (map.containsKey(target - nums[i]) && i != map.get(target - nums[i])) {
-                ans[0] = i;
-                ans[1] = map.get(target - nums[i]);
-                break;
-            }
-        }
-        
-        return ans;
-    }
-}
diff --git a/Explore/Easy/Arrays/Valid Sudoku.java b/Explore/Easy/Arrays/Valid Sudoku.java
deleted file mode 100644
index cc8c7fb0..00000000
--- a/Explore/Easy/Arrays/Valid Sudoku.java	
+++ /dev/null
@@ -1,28 +0,0 @@
-class Solution {
-    public boolean isValidSudoku(char[][] board) {
-        for(int i = 0; i<9; i++){
-            
-            Set<Character> rows = new HashSet<Character>();
-            Set<Character> columns = new HashSet<Character>();
-            Set<Character> cube = new HashSet<Character>();
-            
-            for (int j = 0; j < 9;j++) {
-                
-                if(board[i][j]!='.' && !rows.add(board[i][j]))
-                    return false;
-                
-                if(board[j][i]!='.' && !columns.add(board[j][i]))
-                    return false;
-                
-                int RowIndex = 3*(i/3);
-                int ColIndex = 3*(i%3);
-                
-                if(board[RowIndex + j/3][ColIndex + j%3]!='.' && !cube.add(board[RowIndex + j/3][ColIndex + j%3]))
-                    return false;
-            }
-            
-        }
-        
-        return true;
-    }
-}
diff --git a/Explore/Easy/Design/Min Stack.java b/Explore/Easy/Design/Min Stack.java
deleted file mode 100644
index 41c7c6ed..00000000
--- a/Explore/Easy/Design/Min Stack.java	
+++ /dev/null
@@ -1,42 +0,0 @@
-class MinStack {
-    private Stack<Integer> stack = new Stack<Integer>();
-    private Stack<Integer> minStack = new Stack<Integer>();
-
-    public void push(int x) {
-        stack.push(x);
-        if (minStack.size() != 0) {
-            int min = minStack.peek();
-            if (x <= min) {
-                minStack.push(x);
-            }
-        } else {
-            minStack.push(x);
-        }
-    }
-
-    public void pop() {
-        int x = stack.pop();
-        if (minStack.size() != 0) {
-            if (x == minStack.peek()) {
-                minStack.pop();
-            }
-        }
-    }
-
-    public int top() {
-        return stack.peek();
-    }
-
-    public int getMin() {
-        return minStack.peek();
-    }
-}
-
-/**
- * Your MinStack object will be instantiated and called as such:
- * MinStack obj = new MinStack();
- * obj.push(x);
- * obj.pop();
- * int param_3 = obj.top();
- * int param_4 = obj.getMin();
- */
diff --git a/Explore/Easy/Design/Shuffle an Array.java b/Explore/Easy/Design/Shuffle an Array.java
deleted file mode 100644
index 05fc1174..00000000
--- a/Explore/Easy/Design/Shuffle an Array.java	
+++ /dev/null
@@ -1,40 +0,0 @@
-class Solution {
-    
-    private int[] nums;
-    private Random random;
-
-    public Solution(int[] nums) {
-        this.nums = nums;
-        random = new Random();
-    }
-    
-    /** Resets the array to its original configuration and return it. */
-    public int[] reset() {
-        return nums;
-    }
-    
-    /** Returns a random shuffling of the array. */
-    public int[] shuffle() {
-        if (nums == null) return null;
-        int[] shuf = nums.clone();
-        for (int i=1;i<shuf.length;i++) {
-            int l = random.nextInt(i+1);
-            swap(shuf, i, l);
-        }
-        
-        return shuf;
-    }
-    
-    private void swap(int[] arr, int a, int b) {
-        int temp = arr[a];
-        arr[a] = arr[b];
-        arr[b] = temp;
-    }
-}
-
-/**
- * Your Solution object will be instantiated and called as such:
- * Solution obj = new Solution(nums);
- * int[] param_1 = obj.reset();
- * int[] param_2 = obj.shuffle();
- */
diff --git a/Explore/Easy/Dynamic Programming/Best Time to Buy and Sell Stock.java b/Explore/Easy/Dynamic Programming/Best Time to Buy and Sell Stock.java
deleted file mode 100644
index 3a2590d1..00000000
--- a/Explore/Easy/Dynamic Programming/Best Time to Buy and Sell Stock.java	
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution {
-    public int maxProfit(int[] prices) {
-        
-        if (prices.length == 0) return 0;
-        
-        int min = prices[0];
-        int max = 0;
-        
-        for (int i=1;i<prices.length;i++) {
-            max = Math.max(max, prices[i] - min);
-            min = Math.min(min, prices[i]);
-        }
-        
-        return max;
-    }
-}
diff --git a/Explore/Easy/Dynamic Programming/Climbing Stairs.java b/Explore/Easy/Dynamic Programming/Climbing Stairs.java
deleted file mode 100644
index 3f649382..00000000
--- a/Explore/Easy/Dynamic Programming/Climbing Stairs.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-    public int climbStairs(int n) {
-        int[] memo = new int[n+1];
-        return climbStairs(memo, 0, n);
-    }
-    
-    public int climbStairs(int[] memo, int i, int n) {
-        if (i > n) return 0;
-        if (i == n) return 1;
-        
-        if (memo[i] > 0) return memo[i];
-        
-        memo[i] = climbStairs(memo, i+1, n) + climbStairs(memo, i+2, n);
-        
-        return memo[i];
-    }
-}
diff --git a/Explore/Easy/Dynamic Programming/House Robber.java b/Explore/Easy/Dynamic Programming/House Robber.java
deleted file mode 100644
index 4f5b502c..00000000
--- a/Explore/Easy/Dynamic Programming/House Robber.java	
+++ /dev/null
@@ -1,12 +0,0 @@
-class Solution {
-    public int rob(int[] nums) {
-        int[][] dp = new int[nums.length+1][2];
-        
-        for (int i=1;i<=nums.length;i++) {
-            dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1]);
-            dp[i][1] = nums[i-1] + dp[i-1][0];
-        }
-        
-        return Math.max(dp[nums.length][0], dp[nums.length][1]);
-    }
-}
diff --git a/Explore/Easy/Dynamic Programming/Maximum Subarray.java b/Explore/Easy/Dynamic Programming/Maximum Subarray.java
deleted file mode 100644
index 70fa9505..00000000
--- a/Explore/Easy/Dynamic Programming/Maximum Subarray.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-    public int maxSubArray(int[] nums) {
-        
-        int sum = 0;
-        int max = Integer.MIN_VALUE;
-        int i = 0;
-        
-        while (i<nums.length) {
-            if (sum < 0) {
-                sum = nums[i];
-            }
-            else {
-                sum += nums[i];
-            }
-            
-            max = Math.max(sum,max);
-            i++;
-        }
-        
-        return max;
-    }
-}
diff --git a/Explore/Easy/Linked Lists/Delete Node in a Linked List.java b/Explore/Easy/Linked Lists/Delete Node in a Linked List.java
deleted file mode 100644
index 4f92a369..00000000
--- a/Explore/Easy/Linked Lists/Delete Node in a Linked List.java	
+++ /dev/null
@@ -1,14 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public void deleteNode(ListNode node) {
-        node.val = node.next.val;
-        node.next = node.next.next;
-    }
-}
diff --git a/Explore/Easy/Linked Lists/Linked List Cycle.java b/Explore/Easy/Linked Lists/Linked List Cycle.java
deleted file mode 100644
index a14c6bb1..00000000
--- a/Explore/Easy/Linked Lists/Linked List Cycle.java	
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * Definition for singly-linked list.
- * class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) {
- *         val = x;
- *         next = null;
- *     }
- * }
- */
-public class Solution {
-    public boolean hasCycle(ListNode head) {
-        ListNode slow = head;
-        ListNode fast = head;
-        
-        while (fast != null && fast.next != null) {
-            slow = slow.next;
-            fast = fast.next.next;
-            
-            if (slow == fast) return true;
-        }
-        
-        return false;
-    }
-}
diff --git a/Explore/Easy/Linked Lists/Merge Two Sorted Lists.java b/Explore/Easy/Linked Lists/Merge Two Sorted Lists.java
deleted file mode 100644
index ee054fe9..00000000
--- a/Explore/Easy/Linked Lists/Merge Two Sorted Lists.java	
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
-        
-        if (l1 == null && l2 == null) return null;
-        
-        ListNode ans = new ListNode(0);
-        ListNode temp = ans;
-        
-        while (l1 != null || l2 != null) {
-            if (l1 != null && l2 != null) {
-                if (l1.val > l2.val) {
-                    temp.next = new ListNode(l2.val);
-                    temp = temp.next;
-                    l2 = l2.next;
-                }
-                else {
-                    temp.next = new ListNode(l1.val);
-                    temp = temp.next;
-                    l1 = l1.next;
-                }
-            }
-            else if (l1 != null) {
-                temp.next = new ListNode(l1.val);
-                temp = temp.next;
-                l1 = l1.next;
-            }
-            else if (l2 != null) {
-                temp.next = new ListNode(l2.val);
-                temp = temp.next;
-                l2 = l2.next;
-            }
-        }
-        
-        return ans.next;
-    }
-}
diff --git a/Explore/Easy/Linked Lists/Palindrome Linked List.java b/Explore/Easy/Linked Lists/Palindrome Linked List.java
deleted file mode 100644
index 2b7a5c25..00000000
--- a/Explore/Easy/Linked Lists/Palindrome Linked List.java	
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public boolean isPalindrome(ListNode head) {
-        if (head == null || head.next == null) return true;
-        int l = 0;
-        ListNode curr = head;
-        
-        while (curr != null) {
-            l++;
-            curr = curr.next;
-        }
-        
-        int i = 1;
-        curr = head;
-        
-        while (i < l/2) {
-            curr = curr.next;
-            i++;
-        }
-        
-        ListNode mid = reverse(curr.next);
-        
-        curr = head;
-        
-        while(mid != null) {
-            if (curr.val != mid.val) return false;
-            curr = curr.next;
-            mid = mid.next;
-        }
-        
-        return true;
-    }
-    
-    public ListNode reverse(ListNode head) {
-        ListNode curr = head;
-        ListNode prev = null;
-        ListNode next = null;
-        
-        while(curr != null) {
-            next = curr.next;
-            curr.next = prev;
-            prev = curr;
-            curr = next;
-        }
-        
-        return prev;
-    }
-}
diff --git a/Explore/Easy/Linked Lists/Remove Nth Node From End of List.java b/Explore/Easy/Linked Lists/Remove Nth Node From End of List.java
deleted file mode 100644
index a319e3ec..00000000
--- a/Explore/Easy/Linked Lists/Remove Nth Node From End of List.java	
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public ListNode removeNthFromEnd(ListNode head, int n) {
-        int l = 0;
-        ListNode curr = head;
-        
-        while (curr != null) {
-            l++;
-            curr = curr.next;
-        }
-        
-        if (l -n == 0) {
-            ListNode tmp = head.next;
-            head = null;
-            return tmp;
-        }
-        
-        curr = head;
-        int c = 1;
-        l = l-n;
-        
-        while(c != l) {
-            c++;
-            curr = curr.next;
-        }
-        
-        curr.next = curr.next.next;
-        
-        return head;
-    }
-}
diff --git a/Explore/Easy/Linked Lists/Reverse Linked List.java b/Explore/Easy/Linked Lists/Reverse Linked List.java
deleted file mode 100644
index 8aeaa6ae..00000000
--- a/Explore/Easy/Linked Lists/Reverse Linked List.java	
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public ListNode reverseList(ListNode head) {
-        ListNode curr = head;
-        ListNode prev = null;
-        ListNode next = null;
-        
-        while (curr != null) {
-            next = curr.next;
-            curr.next = prev;
-            prev = curr;
-            curr = next;
-        }
-        
-        return prev;
-    }
-}
diff --git a/Explore/Easy/Math/Count Primes.java b/Explore/Easy/Math/Count Primes.java
deleted file mode 100644
index cce1c733..00000000
--- a/Explore/Easy/Math/Count Primes.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-    public int countPrimes(int n) {
-        int[] arr = new int[n];
-        
-        for (int i=2;i<n;i++) {
-            if (arr[i] != 1) {            
-                for (int j = i*2;j<n;j+=i) {
-                    arr[j] = 1;
-                }
-            } 
-        }
-        
-        int count = 0;
-        
-        for (int i=2;i<n;i++) {
-            if (arr[i] == 0) count++;
-        }
-        
-        return count;
-    }
-}
diff --git a/Explore/Easy/Math/Fizz Buzz.java b/Explore/Easy/Math/Fizz Buzz.java
deleted file mode 100644
index c0c135a6..00000000
--- a/Explore/Easy/Math/Fizz Buzz.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-    public List<String> fizzBuzz(int n) {
-        List<String> ans = new ArrayList<>();
-        for (int i=1;i<=n;i++) {
-            if (i%3 != 0 && i%5 != 0) {
-                ans.add(String.valueOf(i));
-            }
-            else if (i%3 == 0 && i%5 == 0) {
-                ans.add("FizzBuzz");
-            }
-            else if(i%3 == 0) {
-                ans.add("Fizz");
-            }
-            else {
-                ans.add("Buzz");
-            }
-        }
-        
-        return ans;
-    }
-}
diff --git a/Explore/Easy/Math/Power of Three.java b/Explore/Easy/Math/Power of Three.java
deleted file mode 100644
index ed03bb74..00000000
--- a/Explore/Easy/Math/Power of Three.java	
+++ /dev/null
@@ -1,11 +0,0 @@
-class Solution {
-    public boolean isPowerOfThree(int n) {
-        if (n < 1) return false;
-        
-        while (n%3 == 0) {
-            n /= 3;
-        }
-        
-        return n == 1;
-    }
-}
diff --git a/Explore/Easy/Math/Roman to Integer.java b/Explore/Easy/Math/Roman to Integer.java
deleted file mode 100644
index 2078e1d5..00000000
--- a/Explore/Easy/Math/Roman to Integer.java	
+++ /dev/null
@@ -1,39 +0,0 @@
-class Solution {
-    public int romanToInt(String s) {
-        String symbol = "IVXLCDM";
-        int[] val = {1, 5, 10, 50, 100, 500, 1000};
-        
-        char[] s_char = s.toCharArray();
-        
-        int[] s_val = new int[s_char.length];
-        
-        for (int i=0;i<s_char.length;i++) {
-            s_val[i] = val[symbol.indexOf(s_char[i])];
-        }
-        
-        int total = 0;
-        int k = 0;
-        
-        while (k < s_val.length) {
-            int s1  = s_val[k];
-            if (k+1 < s_val.length) {
-                int s2 = s_val[k+1];
-                
-                if (s1 >= s2) {
-                    total += s1;
-                    k++;
-                }
-                else{
-                    total += s2-s1;
-                    k += 2;
-                }
-            }
-            else {
-                total += s1;
-                k++;
-            }
-        }
-        
-        return total;
-    }
-}
diff --git a/Explore/Easy/Others/Hamming Distance.java b/Explore/Easy/Others/Hamming Distance.java
deleted file mode 100644
index 057a1b25..00000000
--- a/Explore/Easy/Others/Hamming Distance.java	
+++ /dev/null
@@ -1,5 +0,0 @@
-class Solution {
-    public int hammingDistance(int x, int y) {
-        return Integer.bitCount(x^y);
-    }
-}
diff --git a/Explore/Easy/Others/Missing Number.java b/Explore/Easy/Others/Missing Number.java
deleted file mode 100644
index c9886640..00000000
--- a/Explore/Easy/Others/Missing Number.java	
+++ /dev/null
@@ -1,11 +0,0 @@
-class Solution {
-    public int missingNumber(int[] nums) {
-        int xor = 0;
-        int i = 0;
-        for (i=0;i<nums.length;i++) {
-            xor = xor^i^nums[i];
-        }
-        
-        return xor^i;
-    }
-}
diff --git a/Explore/Easy/Others/Number of 1 Bits.java b/Explore/Easy/Others/Number of 1 Bits.java
deleted file mode 100644
index 94be5ba9..00000000
--- a/Explore/Easy/Others/Number of 1 Bits.java	
+++ /dev/null
@@ -1,6 +0,0 @@
-public class Solution {
-    // you need to treat n as an unsigned value
-    public int hammingWeight(int n) {
-        return Integer.bitCount(n);
-    }
-}
diff --git a/Explore/Easy/Others/Pascal's Triangle.java b/Explore/Easy/Others/Pascal's Triangle.java
deleted file mode 100644
index 7b1f91d6..00000000
--- a/Explore/Easy/Others/Pascal's Triangle.java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class Solution {
-    
-    Map<Integer, Integer> map = new HashMap<>();
-    public List<List<Integer>> generate(int numRows) {
-        List<List<Integer>> ans = new ArrayList<>();
-        
-        for (int i=0;i<numRows;i++) {
-            List<Integer> temp = new ArrayList<>();
-            for(int j = 0;j<=i;j++) {
-                if (i == j || j == 0) {
-                    temp.add(1);
-                }
-                else {
-                    temp.add(ans.get(i-1).get(j-1) + ans.get(i-1).get(j));
-                }
-            }
-            
-            ans.add(temp);
-        }
-        
-        return ans;
-    }
-}
diff --git a/Explore/Easy/Others/Reverse Bits.java b/Explore/Easy/Others/Reverse Bits.java
deleted file mode 100644
index 36ec5763..00000000
--- a/Explore/Easy/Others/Reverse Bits.java	
+++ /dev/null
@@ -1,13 +0,0 @@
-public class Solution {
-    // you need treat n as an unsigned value
-    public int reverseBits(int n) {
-        int result = 0;
-        for (int i = 0; i < 32; i++) {
-            result += n & 1;
-            n >>>= 1;    
-            if (i < 31) 
-                result <<= 1;
-        }
-        return result;
-    }
-}
diff --git a/Explore/Easy/Others/Valid Parantheses.java b/Explore/Easy/Others/Valid Parantheses.java
deleted file mode 100644
index 10033b6a..00000000
--- a/Explore/Easy/Others/Valid Parantheses.java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class Solution {
-    public boolean isValid(String s) {
-        String start = "({[";
-        String end = ")}]";
-        
-        Stack<Character> stack = new Stack<>();
-        
-        for (int i=0;i<s.length();i++) {
-            if (start.indexOf(s.charAt(i)) != -1) {
-                stack.push(s.charAt(i));
-            }
-            else if (end.indexOf(s.charAt(i)) != -1) {
-                if (stack.empty()) return false;
-                char c = stack.pop();
-                if (start.indexOf(c) != end.indexOf(s.charAt(i))) {
-                    return false;
-                } 
-            }
-        }
-        
-        return stack.empty();
-    }
-}
diff --git a/Explore/Easy/Sorting and Searching/First Bad Version.java b/Explore/Easy/Sorting and Searching/First Bad Version.java
deleted file mode 100644
index 425e47fc..00000000
--- a/Explore/Easy/Sorting and Searching/First Bad Version.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-/* The isBadVersion API is defined in the parent class VersionControl.
-      boolean isBadVersion(int version); */
-
-public class Solution extends VersionControl {
-    public int firstBadVersion(int n) {
-        int start = 1;
-        int end = n;
-        
-        while (start < end) {
-            int mid = start + (end - start) / 2;
-            
-            if (isBadVersion(mid)) {
-                end = mid;
-            }
-            else {
-                start = mid + 1;
-            }
-        }
-        
-        return start;
-    }
-}
diff --git a/Explore/Easy/Sorting and Searching/Merge Sorted Array.java b/Explore/Easy/Sorting and Searching/Merge Sorted Array.java
deleted file mode 100644
index 87a9690c..00000000
--- a/Explore/Easy/Sorting and Searching/Merge Sorted Array.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-    public void merge(int[] nums1, int m, int[] nums2, int n) {
-        int i = m-1;
-        int j = n-1;
-        int k = m+n-1;
-        
-        while (i>=0 && j>=0) {
-            if (nums1[i] > nums2[j]) {
-                nums1[k--] = nums1[i--];
-            }
-            else {
-                nums1[k--] = nums2[j--];
-            }
-        }
-        
-        while(j >= 0) {
-            nums1[k--] = nums2[j--];
-        }
-    }
-}
diff --git a/Explore/Easy/Strings/Count and Say.java b/Explore/Easy/Strings/Count and Say.java
deleted file mode 100644
index 8fd83c74..00000000
--- a/Explore/Easy/Strings/Count and Say.java	
+++ /dev/null
@@ -1,32 +0,0 @@
-class Solution {
-    public String countAndSay(int n) {
-        String first = "1";
-        String str = "11";
-        
-        if (n == 1) return first;
-        if (n == 2) return str;
-        
-        for (int i = 3; i<=n; i++) {
-            str += "$";
-            int len = str.length();
-
-            int cnt = 1; 
-            String  tmp = ""; 
-            
-            for (int j = 1; j < len; j++) {
-                if (str.charAt(j) != str.charAt(j-1)) {
-                    tmp += String.valueOf(cnt);
-                    tmp += str.charAt(j-1);
-
-                    cnt = 1;
-                }
-
-                else cnt++;
-            }
-
-            str = tmp;
-        }
-        
-        return str;
-    }
-}
diff --git a/Explore/Easy/Strings/First Unique Character in a String.java b/Explore/Easy/Strings/First Unique Character in a String.java
deleted file mode 100644
index 5c20c16d..00000000
--- a/Explore/Easy/Strings/First Unique Character in a String.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-    public int firstUniqChar(String s) {
-        int[] ascii = new int[26];
-        
-        for (int i=0;i<s.length();i++) {
-            ascii[(int)s.charAt(i) - 97]++;
-        }
-        
-        for (int i=0;i<s.length();i++) {
-            if (ascii[(int)s.charAt(i) - 97] == 1) {
-                return i;
-            }
-        }
-        
-        return -1;
-    }
-}
diff --git a/Explore/Easy/Strings/Implement strStr().java b/Explore/Easy/Strings/Implement strStr().java
deleted file mode 100644
index db948701..00000000
--- a/Explore/Easy/Strings/Implement strStr().java	
+++ /dev/null
@@ -1,5 +0,0 @@
-class Solution {
-    public int strStr(String haystack, String needle) {
-        return haystack.indexOf(needle);
-    }
-}
diff --git a/Explore/Easy/Strings/Longest Common Prefix.java b/Explore/Easy/Strings/Longest Common Prefix.java
deleted file mode 100644
index ed905d22..00000000
--- a/Explore/Easy/Strings/Longest Common Prefix.java	
+++ /dev/null
@@ -1,15 +0,0 @@
-class Solution {
-    public String longestCommonPrefix(String[] strs) {
-        if (strs == null || strs.length == 0) return "";
-        
-        String ans = strs[0];
-        
-        for (int i=1;i<strs.length;i++) {
-            while(strs[i].indexOf(ans) != 0) {
-                ans = ans.substring(0,ans.length()-1);
-            }
-        }
-        
-        return ans;
-    }
-}
diff --git a/Explore/Easy/Strings/Reverse Integer.java b/Explore/Easy/Strings/Reverse Integer.java
deleted file mode 100644
index 830f4c1e..00000000
--- a/Explore/Easy/Strings/Reverse Integer.java	
+++ /dev/null
@@ -1,18 +0,0 @@
-class Solution {
-    public int reverse(int x) {
-        int res = 0;
-        while(x != 0) {
-            int rem = x % 10;
-            int newres = res * 10 + rem;
-
-            if ((newres - rem) / 10 != res) { 
-                return 0; 
-            }
-
-            res = newres;
-            x = x / 10;
-        }
-
-        return res;
-    }
-}
diff --git a/Explore/Easy/Strings/Reverse String.java b/Explore/Easy/Strings/Reverse String.java
deleted file mode 100644
index 3d0d69b2..00000000
--- a/Explore/Easy/Strings/Reverse String.java	
+++ /dev/null
@@ -1,6 +0,0 @@
-class Solution {
-    public String reverseString(String s) {
-        StringBuilder sb = new StringBuilder(s);
-        return sb.reverse().toString();
-    }
-}
diff --git a/Explore/Easy/Strings/String to Integer.java b/Explore/Easy/Strings/String to Integer.java
deleted file mode 100644
index 54f25d7a..00000000
--- a/Explore/Easy/Strings/String to Integer.java	
+++ /dev/null
@@ -1,32 +0,0 @@
-class Solution {
-    public int myAtoi(String str) {
-        int i = 0;
-        str = str.trim();        
-        char[] c = str.toCharArray();
-
-        int sign = 1;
-        
-        if (i < c.length && (c[i] == '-' || c[i] == '+')) {
-            
-            if (c[i] == '-') {
-                sign = -1;
-            }
-            
-            i++;
-        }      
-
-        int num = 0;
-        int bound = Integer.MAX_VALUE / 10;
-        
-        while (i < c.length && c[i] >= '0' && c[i] <= '9') {
-            int digit = c[i] - '0';
-            if (num > bound || (num == bound && digit > 7)) {
-                return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
-            }
-            
-            num = num * 10 + digit;
-            i++;
-        }
-        return sign * num;
-    }
-}
diff --git a/Explore/Easy/Strings/Valid Anagram.java b/Explore/Easy/Strings/Valid Anagram.java
deleted file mode 100644
index aaa0953a..00000000
--- a/Explore/Easy/Strings/Valid Anagram.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-    public boolean isAnagram(String s, String t) {
-        
-        if (s.length() != t.length()) return false;
-        
-        int[] ascii = new int[26];
-        
-        for (int i=0;i<s.length();i++) {
-            ascii[(int)s.charAt(i) - 97]++;
-        }
-        
-        for (int i=0;i<t.length();i++) {
-            ascii[(int)t.charAt(i) - 97]--;
-        }
-        
-        for (int i=0;i<26;i++) {
-            if (ascii[i] != 0) return false;
-        }
-        
-        return true;
-    }
-}
diff --git a/Explore/Easy/Strings/Valid Palindrome.java b/Explore/Easy/Strings/Valid Palindrome.java
deleted file mode 100644
index e422c169..00000000
--- a/Explore/Easy/Strings/Valid Palindrome.java	
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution {
-    public boolean isPalindrome(String s) {
-        
-        if (s == " " || s.length() <= 1) return true;
-        
-        StringBuilder sb = new StringBuilder("");
-       
-        for(int i=0;i<s.length();i++) {
-            if (((int) s.charAt(i) >= 97 && (int) s.charAt(i) <= 122) || Character.isDigit(s.charAt(i))) {
-                sb.append(String.valueOf(s.charAt(i)));
-            }
-        }
-        
-        return sb.toString().toLowerCase().equals(sb.reverse().toString().toLowerCase());
-    }
-}
diff --git a/Explore/Easy/Trees/Binary Tree Level Order Traversal.java b/Explore/Easy/Trees/Binary Tree Level Order Traversal.java
deleted file mode 100644
index c1323496..00000000
--- a/Explore/Easy/Trees/Binary Tree Level Order Traversal.java	
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public List<List<Integer>> levelOrder(TreeNode root) {
-        Queue<TreeNode> queue = new LinkedList<>();
-        List<List<Integer>> ans = new ArrayList<>();
-        
-        if (root == null) return ans;
-        
-        queue.add(root);
-        
-        while(!queue.isEmpty()) {
-            List<TreeNode> temp = new ArrayList<>();
-            while (!queue.isEmpty()) {
-                temp.add(queue.remove());
-            }
-            
-            List<Integer> lst = new ArrayList<>();
-            
-            for (TreeNode t : temp) {
-                lst.add(t.val);
-                
-                if (t.left != null) queue.add(t.left);
-                if (t.right != null) queue.add(t.right);
-            }
-            
-            ans.add(lst);
-        }
-        
-        return ans;
-    }
-}
diff --git a/Explore/Easy/Trees/Convert Sorted Array to Binary Search Tree.java b/Explore/Easy/Trees/Convert Sorted Array to Binary Search Tree.java
deleted file mode 100644
index 92393eda..00000000
--- a/Explore/Easy/Trees/Convert Sorted Array to Binary Search Tree.java	
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public TreeNode sortedArrayToBST(int[] nums) {
-        return sortedArrayToBST(nums, 0, nums.length-1);
-    }
-    
-    public TreeNode sortedArrayToBST(int arr[], int start, int end) {
- 
-        if (start > end) {
-            return null;
-        }
- 
-        int mid = (start + end) / 2;
-        
-        TreeNode node = new TreeNode(arr[mid]);
-        node.left = sortedArrayToBST(arr, start, mid - 1);
-        node.right = sortedArrayToBST(arr, mid + 1, end);
-         
-        return node;
-    }
-}
diff --git a/Explore/Easy/Trees/Maximum Depth of Binary Tree.java b/Explore/Easy/Trees/Maximum Depth of Binary Tree.java
deleted file mode 100644
index 8dc92307..00000000
--- a/Explore/Easy/Trees/Maximum Depth of Binary Tree.java	
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public int maxDepth(TreeNode root) {
-        if (root == null) return 0;
-        
-        return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
-    }
-}
diff --git a/Explore/Easy/Trees/Symmetric Tree.java b/Explore/Easy/Trees/Symmetric Tree.java
deleted file mode 100644
index 65a6d838..00000000
--- a/Explore/Easy/Trees/Symmetric Tree.java	
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public boolean isSymmetric(TreeNode root) {
-        if (root == null) return true;
-        
-        return isSymmetric(root.left, root.right);
-    }
-    
-    public boolean isSymmetric(TreeNode rLeft, TreeNode rRight) {
-        if (rLeft == null && rRight == null) {
-            return true;
-        }
-        if ((rLeft == null && rRight != null) || (rLeft != null && rRight == null)) {
-            return false;
-        }
-        
-        if (rLeft != null && rRight != null) {
-            if (rLeft.val != rRight.val) return false;
-        }
-        
-        return isSymmetric(rLeft.left, rRight.right) && isSymmetric(rLeft.right, rRight.left);
-    }
-}
diff --git a/Explore/Easy/Trees/Validate Binary Search Tree.java b/Explore/Easy/Trees/Validate Binary Search Tree.java
deleted file mode 100644
index ad07834a..00000000
--- a/Explore/Easy/Trees/Validate Binary Search Tree.java	
+++ /dev/null
@@ -1,32 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public boolean isValidBST(TreeNode root) {
-        Stack<TreeNode> stack = new Stack<>();
-        TreeNode prev = null;
-        
-        while (root != null || !stack.empty()) {
-            while(root != null) {
-                stack.push(root);
-                root = root.left;
-            }
-            
-            if (prev != null && prev.val >= stack.peek().val) {
-                return false;
-            }
-            
-            root = stack.pop();
-            prev = root;
-            root = root.right;
-        }
-        
-        return true;
-    }
-}
diff --git a/Explore/Medium/Arrays and Strings/3Sum.java b/Explore/Medium/Arrays and Strings/3Sum.java
deleted file mode 100644
index fa68d8bb..00000000
--- a/Explore/Medium/Arrays and Strings/3Sum.java	
+++ /dev/null
@@ -1,34 +0,0 @@
-class Solution {
-    public List<List<Integer>> threeSum(int[] nums) {
-        
-        Arrays.sort(nums);
-        
-        List<List<Integer>> ans = new ArrayList<>();
-        
-        for (int i=0;i<nums.length-2;i++) {
-            if (i > 0 && nums[i] == nums[i-1]) continue;
-            
-            int j = i+1;
-            int k = nums.length-1;
-            
-            int target = -nums[i];
-            
-            while (j<k) {
-                if (nums[j] + nums[k] == target) {
-                    ans.add(Arrays.asList(nums[i], nums[j], nums[k]));
-                    j++;
-                    k--;
-
-                    while(j < k && nums[j] == nums[j-1]) j++;
-                    while(j < k && nums[k] == nums[k+1]) k--;
-                }
-                else if (nums[j] + nums[k] > target) k--;
-                else {
-                    j++;
-                }
-            }
-        }
-        
-        return ans;
-    }
-}
diff --git a/Explore/Medium/Arrays and Strings/Group Anagrams.java b/Explore/Medium/Arrays and Strings/Group Anagrams.java
deleted file mode 100644
index 758782ae..00000000
--- a/Explore/Medium/Arrays and Strings/Group Anagrams.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-class Solution {
-    public List<List<String>> groupAnagrams(String[] strs) {
-        Map<String, List<String>> map = new HashMap<>();
-        
-        for (String s : strs) {
-            char[] ar = s.toCharArray();
-            Arrays.sort(ar);
-            String s_sorted = String.valueOf(ar);
-            
-            if (map.containsKey(s_sorted)) {
-                List<String> temp = map.get(s_sorted);
-                temp.add(s);
-                map.put(s_sorted, temp);
-            }
-            else {
-                List<String> temp = new ArrayList<>();
-                temp.add(s);
-                map.put(s_sorted, temp);
-            }
-        }
-        
-        List<List<String>> ans = new ArrayList<>();
-        
-        for (Map.Entry<String, List<String>> entry : map.entrySet()) {
-            ans.add(entry.getValue());
-        }
-        
-        return ans;
-    }
-}
diff --git a/Explore/Medium/Arrays and Strings/Increasing Triplet Subsequence.java b/Explore/Medium/Arrays and Strings/Increasing Triplet Subsequence.java
deleted file mode 100644
index b90490c6..00000000
--- a/Explore/Medium/Arrays and Strings/Increasing Triplet Subsequence.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-    public boolean increasingTriplet(int[] nums) {
-        if (nums.length < 3) return false;
-
-        int x = Integer.MAX_VALUE;
-        int y = Integer.MAX_VALUE;
-    
-        for (int i=0;i<nums.length;i++) {
-            int z = nums[i];
-            if (x >= z) {
-                x = z;
-            }
-            else if (y >= z) {
-                y = z;
-            }
-            else return true;
-        }
-        
-        return false;
-    }
-}
diff --git a/Explore/Medium/Arrays and Strings/Longest Palindromic Substring.java b/Explore/Medium/Arrays and Strings/Longest Palindromic Substring.java
deleted file mode 100644
index 569508e3..00000000
--- a/Explore/Medium/Arrays and Strings/Longest Palindromic Substring.java	
+++ /dev/null
@@ -1,28 +0,0 @@
-class Solution {
-    public String longestPalindrome(String s) {
-        int start = 0;
-        int end = 0;
-        
-        for (int i=0;i<s.length();i++) {
-            int len1 = expandCenter(s, i, i);
-            int len2 = expandCenter(s, i, i+1);
-            int len = Math.max(len1, len2);
-            
-            if (len > end - start) {
-                start = i - (len - 1)/2;
-                end = i + len/2;
-            }
-        }
-        
-        return s.substring(start, end+1);
-    }
-    
-    public int expandCenter(String s, int left, int right) {
-        while (left >=0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
-            left--;
-            right++;
-        }
-        
-        return right - left - 1;
-    }
-}
diff --git a/Explore/Medium/Arrays and Strings/Longest Substring Without Repeating Characters.java b/Explore/Medium/Arrays and Strings/Longest Substring Without Repeating Characters.java
deleted file mode 100644
index bde380e6..00000000
--- a/Explore/Medium/Arrays and Strings/Longest Substring Without Repeating Characters.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-    public int lengthOfLongestSubstring(String s) {
-        
-        Set<Character> set = new HashSet<>();
-        int maxLen = Integer.MIN_VALUE;
-        
-        int i=0, j=0;
-        int n = s.length();
-        
-        while(i<n && j<n) {
-            if (!set.contains(s.charAt(j))) {
-                set.add(s.charAt(j++));
-                maxLen = Math.max(maxLen, j-i);
-            }
-            else {
-                set.remove(s.charAt(i++));
-            }
-        }
-        
-        return s.length() == 0 ? 0 : maxLen;
-    }
-}
diff --git a/Explore/Medium/Arrays and Strings/Missing Ranges.java b/Explore/Medium/Arrays and Strings/Missing Ranges.java
deleted file mode 100644
index 4d1f0164..00000000
--- a/Explore/Medium/Arrays and Strings/Missing Ranges.java	
+++ /dev/null
@@ -1,109 +0,0 @@
-class Solution {
-    public static List<String> findMissingRanges(int[] nums, int lower, int upper) {
-        List<String> list = new ArrayList<>();
-
-        if (nums.length == 0) {
-            list.add(getString(lower, upper));
-            return list;
-        }
-
-        List<String> range = getRange(nums);
-        int i = 0;
-
-        while (lower <= upper && i < range.size()) {
-            String s = range.get(i);
-            if (s.indexOf('>') != -1) {
-                int start = Integer.parseInt(s.split("->")[0]);
-                int end = Integer.parseInt(s.split("->")[1]);
-
-                if (lower != start) {
-                    list.add(getString(lower, start-1));
-                }
-
-                lower = end + 1;
-            }
-            else {
-                int num = Integer.parseInt(s);
-                if (lower != num) {
-                    list.add(getString(lower, num-1));
-                }
-
-                lower = num + 1;
-            }
-
-            i++;
-        }
-
-        String s = range.get(range.size()-1);
-        if (s.indexOf('>') != -1) {
-            int start = Integer.parseInt(s.split("->")[0]);
-            int end = Integer.parseInt(s.split("->")[1]);
-
-            if (end != upper) {
-                list.add(getString(end+1, upper));
-            }
-        }
-        else {
-            int num = Integer.parseInt(s);
-            if (upper != num) {
-                list.add(getString(num+1, upper));
-            }
-        }
-
-        return list;
-    }
-
-    private static List<String> getRange(int[] num) {
-
-        List<String> list = new ArrayList<>();
-        if (num.length == 0) {
-            return list;
-        }
-
-        int i = 1;
-        StringBuilder sb = new StringBuilder();
-        sb.append(num[0]);
-        int count = 1;
-
-        while (i<num.length) {
-            if (num[i] - num[i-1] == 1 || num[i] - num[i-1] == 0) {
-                count++;
-            }
-            else {
-                if (count > 1) {
-                    sb.append("->").append(num[i-1]);
-                    list.add(sb.toString());
-                }
-                else {
-                    list.add(sb.toString());
-                }
-
-                sb = new StringBuilder();
-                sb.append(num[i]);
-                count = 1;
-            }
-
-            i++;
-        }
-        
-        if (count > 1) {
-            sb.append("->").append(num[num.length-1]);
-        }
-
-        list.add(sb.toString());
-
-        return list;
-    }
-
-    private static String getString(int start, int end) {
-        StringBuilder sb = new StringBuilder();
-        if (start == end) {
-            sb.append(start);
-        }
-        else {
-            sb.append(start).append("->").append(end);
-        }
-
-        return sb.toString();
-    }
-}
diff --git a/Explore/Medium/Arrays and Strings/Set Matrix Zeroes.java b/Explore/Medium/Arrays and Strings/Set Matrix Zeroes.java
deleted file mode 100644
index 6c043646..00000000
--- a/Explore/Medium/Arrays and Strings/Set Matrix Zeroes.java	
+++ /dev/null
@@ -1,64 +0,0 @@
-class Solution {
-    public void setZeroes(int[][] arr) {
-        if (arr.length == 0 || arr[0].length == 0) {
-            return;
-        }
-
-
-        int numOfRows = arr.length;
-        int numOfCols = arr[0].length;
-        boolean firstRowZero = false;
-        boolean firstColZero = false;
-
-        for (int i = 0; i < numOfCols; i++) {
-            if (arr[0][i] == 0) {
-                firstRowZero = true;
-                break;
-            }
-        }
-
-        for (int i = 0; i < numOfRows; i++) {
-            if (arr[i][0] == 0) {
-                firstColZero = true;
-                break;
-            }
-        }
-
-        for (int i = 1; i < numOfRows; i++) {
-            for (int j = 0; j < numOfCols; j++) {
-                if (arr[i][j] == 0) {
-                    arr[0][j] = 0;
-                    arr[i][0] = 0;
-                }
-            }
-        }
-
-        for (int i = 1; i < numOfRows; i++) {
-            if (arr[i][0] == 0) {
-                for (int j = 1; j < numOfCols; j++) {
-                    arr[i][j] = 0;
-                }
-            }
-        }
-
-        for (int i = 0; i < numOfCols; i++) {
-            if (arr[0][i] == 0) {
-                for (int j = 1; j < numOfRows; j++) {
-                    arr[j][i] = 0;
-                }
-            }
-        }
-
-        if (firstRowZero) {
-            for (int i = 0; i < numOfCols; i++) {
-                arr[0][i] = 0;
-            }
-        }
-
-        if (firstColZero) {
-            for (int i = 0; i < numOfRows; i++) {
-                arr[i][0] = 0;
-            }
-        }
-    }
-}
diff --git a/Explore/Medium/Linked Lists/Add Two Numbers.java b/Explore/Medium/Linked Lists/Add Two Numbers.java
deleted file mode 100644
index 5ec675ce..00000000
--- a/Explore/Medium/Linked Lists/Add Two Numbers.java	
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-        ListNode ans = new ListNode(0);
-        ListNode curr = ans;
-        
-        int carry = 0;
-        
-        while (l1 != null || l2 != null) {
-            
-            int temp = 0;
-            
-            if (l1 != null && l2 != null) {
-                temp = l1.val + l2.val + carry;
-                l1 = l1.next;
-                l2 = l2.next;
-            }
-            else if (l1 != null && l2 == null) {
-                temp = l1.val + carry;
-                l1 = l1.next;
-            }
-            else if (l1 == null && l2 != null) {
-                temp = l2.val + carry;
-                l2 = l2.next;
-            }
-            
-            carry = temp > 9 ? temp/10 : 0;
-            temp = temp > 9 ? temp%10 : temp;
-            
-            curr.next = new ListNode(temp);
-            curr = curr.next;
-        }
-        
-        if (carry != 0) {
-            curr.next = new ListNode(carry);
-            curr = curr.next;
-        }
-        
-        return ans.next;
-    }
-}
diff --git a/Explore/Medium/Linked Lists/Intersection of Two Linked Lists.java b/Explore/Medium/Linked Lists/Intersection of Two Linked Lists.java
deleted file mode 100644
index 316eefbe..00000000
--- a/Explore/Medium/Linked Lists/Intersection of Two Linked Lists.java	
+++ /dev/null
@@ -1,58 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) {
- *         val = x;
- *         next = null;
- *     }
- * }
- */
-public class Solution {
-    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
-        
-        if (headA == null || headB == null) return null;
-        
-        int lenA = getLength(headA);
-        int lenB = getLength(headB);
-
-        ListNode currA = headA;
-        ListNode currB = headB;
-        
-        if (lenB > lenA) {
-            int diff = lenB - lenA;
-            
-            while (diff != 0) {
-                currB = currB.next;
-                diff--;
-            }
-        }
-        else {
-            int diff = lenA - lenB;
-            
-            while (diff != 0) {
-                currA = currA.next;
-                diff--;
-            }
-        }
-        
-        while(currB != null) {
-            if (currA == currB) return currA;
-            currA = currA.next;
-            currB = currB.next;
-        }
-        
-        return null;
-    }
-    
-    public int getLength(ListNode head) {
-        int l = 0;
-        while (head != null) {
-            head = head.next;
-            l++;
-        }
-        
-        return l;
-    }
-}
diff --git a/Explore/Medium/Linked Lists/Odd Even Linked List.java b/Explore/Medium/Linked Lists/Odd Even Linked List.java
deleted file mode 100644
index 92b55544..00000000
--- a/Explore/Medium/Linked Lists/Odd Even Linked List.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public ListNode oddEvenList(ListNode head) {
-        
-        if (head == null || head.next == null) return head;
-        
-        ListNode odd = head;
-        ListNode even = head.next;
-        ListNode evenHead = even;
-        
-        while(even != null && even.next != null) {
-            odd.next = odd.next.next;
-            even.next = even.next.next;
-            
-            odd = odd.next;
-            even = even.next;
-        }
-        
-        odd.next = evenHead;
-        
-        return head;
-    }
-}
diff --git a/Explore/Medium/Sorting & Searching/Sort Colors.java b/Explore/Medium/Sorting & Searching/Sort Colors.java
deleted file mode 100644
index 4a8fdd4e..00000000
--- a/Explore/Medium/Sorting & Searching/Sort Colors.java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class Solution {
-    public void sortColors(int[] nums) {
-        
-        int n0 = -1;
-        int n1 = -1;
-        int n2 = -1;
-        
-        for (int i=0;i<nums.length;i++) {
-            if (nums[i] == 0) {
-                nums[++n2] = 2;
-                nums[++n1] = 1;
-                nums[++n0] = 0;
-            }
-            else if (nums[i] == 1) {
-                nums[++n2] = 2;
-                nums[++n1] = 1;
-            }
-            else {
-                nums[++n2] = 2;
-            }
-        }
-    }
-}
diff --git a/Explore/Medium/Sorting & Searching/Top K Frequent Elements.java b/Explore/Medium/Sorting & Searching/Top K Frequent Elements.java
deleted file mode 100644
index b33b2b45..00000000
--- a/Explore/Medium/Sorting & Searching/Top K Frequent Elements.java	
+++ /dev/null
@@ -1,29 +0,0 @@
-class Solution {
-    public List<Integer> topKFrequent(int[] nums, int k) {
-        List<Integer>[] bucket = new List[nums.length+1];
-        Map<Integer, Integer> frequencyMap = new HashMap<>();
-        for (int n : nums) {
-            frequencyMap.put(n, frequencyMap.getOrDefault(n, 0) + 1);
-        }
-        
-        for (int key : frequencyMap.keySet()) {
-            int frequency = frequencyMap.get(key);
-            
-            if (bucket[frequency] == null) {
-                bucket[frequency] = new ArrayList<>();
-            }
-            
-            bucket[frequency].add(key);
-        }
-        
-        List<Integer> res = new ArrayList<>();
-        
-        for (int pos = bucket.length - 1; pos >= 0 && res.size() < k; pos--) {
-            if (bucket[pos] != null) {
-                res.addAll(bucket[pos]);
-            }
-        }
-        
-        return res;
-    }
-}
diff --git a/Explore/Medium/Trees and Graphs/Binary Tree Inorder Traversal.java b/Explore/Medium/Trees and Graphs/Binary Tree Inorder Traversal.java
deleted file mode 100644
index 811b92e6..00000000
--- a/Explore/Medium/Trees and Graphs/Binary Tree Inorder Traversal.java	
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public List<Integer> inorderTraversal(TreeNode root) {
-        List<Integer> list = new ArrayList<>();
-        
-        Stack<TreeNode> stack = new Stack<>();
-        
-        while (root != null || !stack.empty()) {
-            
-            while(root != null) {
-                stack.push(root);
-                root = root.left;
-            }
-            
-            root = stack.pop();
-            
-            list.add(root.val);
-            root = root.right;
-        }
-        
-        return list;
-    }
-}
diff --git a/Explore/Medium/Trees and Graphs/Binary Tree Zigzag Level Order Traversal.java b/Explore/Medium/Trees and Graphs/Binary Tree Zigzag Level Order Traversal.java
deleted file mode 100644
index a87e311c..00000000
--- a/Explore/Medium/Trees and Graphs/Binary Tree Zigzag Level Order Traversal.java	
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
-        
-        Stack<TreeNode> s1 = new Stack<>();
-        Stack<TreeNode> s2 = new Stack<>();
-        
-        List<List<Integer>> ans = new ArrayList<>();
-        
-        if (root == null) return ans; 
-        
-        s1.push(root);
-        
-        while (!s1.empty() || !s2.empty()) {
-            
-            List<Integer> list = new ArrayList<>();
-            
-            while (!s1.empty()) {
-                TreeNode temp = s1.pop();
-
-                list.add(temp.val);
-
-                if (temp.left != null) {
-                    s2.add(temp.left);
-                }
-                
-                if (temp.right != null) {
-                    s2.add(temp.right);
-                }
-            }
-            
-            if (list.size() > 0) {
-                ans.add(list);
-                continue;
-            }
-            
-            while (!s2.empty()) {
-                TreeNode temp = s2.pop();
-                list.add(temp.val);
-
-                if (temp.right != null) {
-                    s1.add(temp.right);
-                }
-                
-                if (temp.left != null) {
-                    s1.add(temp.left);
-                }
-
-            }
-            
-            ans.add(list);
-        }
-        
-        return ans;
-    }
-}
diff --git a/Explore/Medium/Trees and Graphs/Construct Binary Tree from Preorder and Inorder Traversal.java b/Explore/Medium/Trees and Graphs/Construct Binary Tree from Preorder and Inorder Traversal.java
deleted file mode 100644
index ddfa9f42..00000000
--- a/Explore/Medium/Trees and Graphs/Construct Binary Tree from Preorder and Inorder Traversal.java	
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public TreeNode buildTree(int[] preorder, int[] inorder) {
-        return buildTreeHelper(0, 0, inorder.length-1, preorder, inorder);
-    }
-    
-    public TreeNode buildTreeHelper(int preStart, int inStart, int inEnd, int[] preorder, int[] inorder) {
-        if (preStart > preorder.length-1 || inStart > inEnd) {
-            return null;
-        }
-        
-        TreeNode root = new TreeNode(preorder[preStart]);
-        int inIndex = -1;
-        
-        for (int i = inStart; i <= inEnd; i++) {
-            if (inorder[i] == root.val) {
-                inIndex = i;
-                break;
-            }
-        }
-        
-        root.left = buildTreeHelper(preStart+1, inStart, inIndex-1, preorder, inorder);
-        root.right = buildTreeHelper(preStart + inIndex - inStart + 1, inIndex + 1, inEnd, preorder, inorder);
-        
-        return root;
-    }
-}
\ No newline at end of file
diff --git a/Explore/Medium/Trees and Graphs/Kth Smallest Element in a BST.java b/Explore/Medium/Trees and Graphs/Kth Smallest Element in a BST.java
deleted file mode 100644
index 6b46a29f..00000000
--- a/Explore/Medium/Trees and Graphs/Kth Smallest Element in a BST.java	
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public int kthSmallest(TreeNode root, int k) {
-        Stack<TreeNode> stack = new Stack<>();
-        List<Integer> list = new ArrayList<>();
-        
-        while(root != null || !stack.empty()) {
-            while (root != null) {
-                stack.push(root);
-                root = root.left;
-            }
-            
-            root = stack.pop();
-            list.add(root.val);
-            root = root.right;
-        }
-        
-        return list.get(k-1);
-    }
-}
diff --git a/Explore/Medium/Trees and Graphs/Populating Next Right Pointers in Each Node.java b/Explore/Medium/Trees and Graphs/Populating Next Right Pointers in Each Node.java
deleted file mode 100644
index b012ec6b..00000000
--- a/Explore/Medium/Trees and Graphs/Populating Next Right Pointers in Each Node.java	
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * Definition for binary tree with next pointer.
- * public class TreeLinkNode {
- *     int val;
- *     TreeLinkNode left, right, next;
- *     TreeLinkNode(int x) { val = x; }
- * }
- */
-public class Solution {
-    public void connect(TreeLinkNode root) {
-        
-        TreeLinkNode start=root;
-        
-        while(start!=null){
-            
-            TreeLinkNode cur=start;
-            
-            while(cur!=null){
-                if(cur.left!=null) cur.left.next=cur.right;
-                if(cur.right!=null && cur.next!=null) cur.right.next=cur.next.left;
-
-                cur=cur.next;
-            }
-            
-            start=start.left;
-        }
-    }
-}

From 119a43ab92a334f77bff4dc9c34dba015efce29b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Nov 2021 16:56:42 -0800
Subject: [PATCH 0628/2175] Delete Contests directory

---
 .../Fruits Into Basket.java                   | 34 -----------
 .../Sort Array By Parity.java                 | 28 ---------
 .../Sum of Subarray Minimums.java             | 32 ----------
 .../Weekly Contest 103/Online Election.java   | 46 ---------------
 .../Weekly Contest 103/Smallest Range I.java  |  7 ---
 .../Weekly Contest 103/Smallest Range II.java | 16 -----
 ...rtition Array into Disjoint Intervals.java | 25 --------
 Contests/Weekly Contest 104/Word Subsets.java | 58 ------------------
 .../X of a Kind in a Deck of Cards.java       | 47 ---------------
 .../Maximum Sum Circular Subarray.java        | 28 ---------
 .../Reverse Only Letters.java                 | 30 ----------
 .../3Sum With Multiplicity.java               | 31 ----------
 ...Minimum Add to Make Parentheses Valid.java | 24 --------
 .../Sort Array By Parity II.java              | 35 -----------
 .../Flip String to Monotone Increasing.java   | 27 ---------
 .../Weekly Contest 107/Long Pressed Name.java | 29 ---------
 .../Binary Subarrays With Sum.java            | 18 ------
 .../Minimum Falling Path Sum.java             | 37 ------------
 .../Unique Email Addresses.java               | 20 -------
 .../Weekly Contest 109/Knight Dialer.java     | 25 --------
 .../Number of Recent Calls.java               | 23 --------
 .../Distinct Subsequence II.java              | 12 ----
 .../Minimum Area Rectangle.java               | 32 ----------
 .../Weekly Contest 110/Range Sum of BST.java  | 39 ------------
 .../Weekly Contest 110/Reorder Log Files.java | 53 -----------------
 .../Weekly Contest 111/DI String Match.java   | 21 -------
 .../Delete Columns to Make Sorted.java        | 22 -------
 .../Valid Mountain Array.java                 | 16 -----
 .../Weekly Contest 112/Bag of Tokens.java     | 31 ----------
 ...inimum Increment to Make Array Unique.java | 19 ------
 ...tones Removed with Same Row or Column.java | 44 --------------
 .../Validate Stack Sequences.java             | 30 ----------
 .../Flip Equivalent Binary Trees.java         | 27 ---------
 .../Largest Time for Given Digits.java        | 57 ------------------
 .../Reveal Cards In Increasing Order.java     | 22 -------
 .../Check Completeness of a Binary Tree.java  | 38 ------------
 ... If Word Is Valid After Substitutions.java | 21 -------
 .../Find Common Characters.java               | 30 ----------
 .../Max Consecutive Ones III.java             | 31 ----------
 .../Weekly Contest 127/Clumsy Factorial.java  | 59 -------------------
 ...y Search Tree from Preorder Traversal.java | 39 ------------
 ...ximize Sum Of Array After K Negations.java | 23 --------
 ...inimum Domino Rotations For Equal Row.java | 25 --------
 .../Best Sightseeing Pair.java                | 13 ----
 ...g With Substrings Representing 1 To N.java | 15 -----
 ...Array Into Three Parts With Equal Sum.java | 30 ----------
 .../Smallest Integer Divisible by K.java      | 17 ------
 .../Camelcase Matching.java                   | 43 --------------
 .../Remove Outermost Parentheses.java         | 22 -------
 .../Sum of Root To Leaf Binary Numbers.java   | 40 -------------
 Contests/Weekly Contest 132/Divisor Game.java |  5 --
 .../Longest Arithmetic Sequence.java          | 35 -----------
 ... Difference Between Node and Ancestor.java | 29 ---------
 53 files changed, 1560 deletions(-)
 delete mode 100644 Contests/Weekly Contest 102/Fruits Into Basket.java
 delete mode 100644 Contests/Weekly Contest 102/Sort Array By Parity.java
 delete mode 100644 Contests/Weekly Contest 102/Sum of Subarray Minimums.java
 delete mode 100644 Contests/Weekly Contest 103/Online Election.java
 delete mode 100644 Contests/Weekly Contest 103/Smallest Range I.java
 delete mode 100644 Contests/Weekly Contest 103/Smallest Range II.java
 delete mode 100644 Contests/Weekly Contest 104/Partition Array into Disjoint Intervals.java
 delete mode 100644 Contests/Weekly Contest 104/Word Subsets.java
 delete mode 100644 Contests/Weekly Contest 104/X of a Kind in a Deck of Cards.java
 delete mode 100644 Contests/Weekly Contest 105/Maximum Sum Circular Subarray.java
 delete mode 100644 Contests/Weekly Contest 105/Reverse Only Letters.java
 delete mode 100644 Contests/Weekly Contest 106/3Sum With Multiplicity.java
 delete mode 100644 Contests/Weekly Contest 106/Minimum Add to Make Parentheses Valid.java
 delete mode 100644 Contests/Weekly Contest 106/Sort Array By Parity II.java
 delete mode 100644 Contests/Weekly Contest 107/Flip String to Monotone Increasing.java
 delete mode 100644 Contests/Weekly Contest 107/Long Pressed Name.java
 delete mode 100644 Contests/Weekly Contest 108/Binary Subarrays With Sum.java
 delete mode 100644 Contests/Weekly Contest 108/Minimum Falling Path Sum.java
 delete mode 100644 Contests/Weekly Contest 108/Unique Email Addresses.java
 delete mode 100644 Contests/Weekly Contest 109/Knight Dialer.java
 delete mode 100644 Contests/Weekly Contest 109/Number of Recent Calls.java
 delete mode 100644 Contests/Weekly Contest 110/Distinct Subsequence II.java
 delete mode 100644 Contests/Weekly Contest 110/Minimum Area Rectangle.java
 delete mode 100644 Contests/Weekly Contest 110/Range Sum of BST.java
 delete mode 100644 Contests/Weekly Contest 110/Reorder Log Files.java
 delete mode 100644 Contests/Weekly Contest 111/DI String Match.java
 delete mode 100644 Contests/Weekly Contest 111/Delete Columns to Make Sorted.java
 delete mode 100644 Contests/Weekly Contest 111/Valid Mountain Array.java
 delete mode 100644 Contests/Weekly Contest 112/Bag of Tokens.java
 delete mode 100644 Contests/Weekly Contest 112/Minimum Increment to Make Array Unique.java
 delete mode 100644 Contests/Weekly Contest 112/Most Stones Removed with Same Row or Column.java
 delete mode 100644 Contests/Weekly Contest 112/Validate Stack Sequences.java
 delete mode 100644 Contests/Weekly Contest 113/Flip Equivalent Binary Trees.java
 delete mode 100644 Contests/Weekly Contest 113/Largest Time for Given Digits.java
 delete mode 100644 Contests/Weekly Contest 113/Reveal Cards In Increasing Order.java
 delete mode 100644 Contests/Weekly Contest 115/Check Completeness of a Binary Tree.java
 delete mode 100644 Contests/Weekly Contest 126/Check If Word Is Valid After Substitutions.java
 delete mode 100644 Contests/Weekly Contest 126/Find Common Characters.java
 delete mode 100644 Contests/Weekly Contest 126/Max Consecutive Ones III.java
 delete mode 100644 Contests/Weekly Contest 127/Clumsy Factorial.java
 delete mode 100644 Contests/Weekly Contest 127/Construct Binary Search Tree from Preorder Traversal.java
 delete mode 100644 Contests/Weekly Contest 127/Maximize Sum Of Array After K Negations.java
 delete mode 100644 Contests/Weekly Contest 127/Minimum Domino Rotations For Equal Row.java
 delete mode 100644 Contests/Weekly Contest 129/Best Sightseeing Pair.java
 delete mode 100644 Contests/Weekly Contest 129/Binary String With Substrings Representing 1 To N.java
 delete mode 100644 Contests/Weekly Contest 129/Partition Array Into Three Parts With Equal Sum.java
 delete mode 100644 Contests/Weekly Contest 129/Smallest Integer Divisible by K.java
 delete mode 100644 Contests/Weekly Contest 131/Camelcase Matching.java
 delete mode 100644 Contests/Weekly Contest 131/Remove Outermost Parentheses.java
 delete mode 100644 Contests/Weekly Contest 131/Sum of Root To Leaf Binary Numbers.java
 delete mode 100644 Contests/Weekly Contest 132/Divisor Game.java
 delete mode 100644 Contests/Weekly Contest 132/Longest Arithmetic Sequence.java
 delete mode 100644 Contests/Weekly Contest 132/Maximum Difference Between Node and Ancestor.java

diff --git a/Contests/Weekly Contest 102/Fruits Into Basket.java b/Contests/Weekly Contest 102/Fruits Into Basket.java
deleted file mode 100644
index 6d509ca1..00000000
--- a/Contests/Weekly Contest 102/Fruits Into Basket.java	
+++ /dev/null
@@ -1,34 +0,0 @@
-class Solution {
-    public static int totalFruit(int[] tree) {
-        int maxFruits = Integer.MIN_VALUE;
-        int count = 0;
-        Map<Integer, Integer> map = new HashMap<>();
-        int start = 0;
-
-        for (int num : tree) {
-            if (map.size() < 2 || map.containsKey(num)) {
-                map.put(num, map.getOrDefault(num, 0) + 1);
-                count++;
-            }
-            else {
-                map.put(num, map.getOrDefault(num, 0) + 1);
-                count++;
-
-                while (true) {
-                    int key = tree[start++];
-                    map.put(key, map.get(key)-1);
-                    count--;
-
-                    if (map.get(key) == 0) {
-                        map.remove(key);
-                        break;
-                    }
-                }
-            }
-
-            maxFruits = Math.max(maxFruits, count);
-        }
-
-        return Math.max(count, maxFruits);
-    }
-}
diff --git a/Contests/Weekly Contest 102/Sort Array By Parity.java b/Contests/Weekly Contest 102/Sort Array By Parity.java
deleted file mode 100644
index 96bf6ca0..00000000
--- a/Contests/Weekly Contest 102/Sort Array By Parity.java	
+++ /dev/null
@@ -1,28 +0,0 @@
-class Solution {
-    public static int[] sortArrayByParity(int[] A) {
-        List<Integer> even = new ArrayList<>();
-        List<Integer> odd = new ArrayList<>();
-
-
-        for (int num : A) {
-            if (num%2 == 0) {
-                even.add(num);
-            }
-            else {
-                odd.add(num);
-            }
-        }
-
-        int i = 0;
-
-        for (int num : even) {
-            A[i++] = num;
-        }
-
-        for (int num : odd) {
-            A[i++] = num;
-        }
-
-        return A;
-    }
-}
diff --git a/Contests/Weekly Contest 102/Sum of Subarray Minimums.java b/Contests/Weekly Contest 102/Sum of Subarray Minimums.java
deleted file mode 100644
index 5126978f..00000000
--- a/Contests/Weekly Contest 102/Sum of Subarray Minimums.java	
+++ /dev/null
@@ -1,32 +0,0 @@
-class Solution {
-    public static int sumSubarrayMins(int[] A) {
-        Stack<List<Integer>> stack = new Stack<>();
-        int n = A.length;
-        int tempSum = 0;
-        int mod = 1000000007;
-        int ans = 0;
-
-        for (int i = 0; i < n; i++) {
-            if((!stack.empty()) && A[i] >= stack.peek().get(0)) {
-                tempSum += A[i];
-                stack.push(Arrays.asList(A[i], 1));
-            }
-            else {
-                int count = 1;
-
-                while((!stack.empty()) && stack.peek().get(0) > A[i]) {
-                    count += stack.peek().get(1);
-                    tempSum -= stack.peek().get(1) * stack.peek().get(0);
-                    stack.pop();
-                }
-
-                stack.push(Arrays.asList(A[i], count));
-                tempSum += count * A[i];
-            }
-
-            ans = (ans + tempSum)%mod;
-        }
-
-        return ans;
-    }
-}
diff --git a/Contests/Weekly Contest 103/Online Election.java b/Contests/Weekly Contest 103/Online Election.java
deleted file mode 100644
index 86ed54fa..00000000
--- a/Contests/Weekly Contest 103/Online Election.java	
+++ /dev/null
@@ -1,46 +0,0 @@
-class TopVotedCandidate {
-    int[] times;
-    int[] persons;
-    int[] winner;
-
-    public TopVotedCandidate(int[] persons, int[] times) {
-        this.times = times;
-        this.persons = persons;
-        int[] counter = new int[persons.length+1];
-        winner = new int[times.length];
-        int max = Integer.MIN_VALUE;
-        int maxPerson = -1;
-        int i = 0;
-
-        while (i < times.length) {
-            counter[persons[i]]++;
-            if (max < counter[persons[i]]) {
-                max = counter[persons[i]];
-                maxPerson = persons[i];
-            }
-            else if (max == counter[persons[i]]) {
-                maxPerson = persons[i];
-            }
-
-            winner[i] = maxPerson;
-
-            i++;
-        }
-    }
-
-    public int q(int t) {
-        int i = 0;
-        while (i < times.length && times[i] <= t) {
-            i++;
-        }
-
-        return winner[i-1];
-    }
-}
-
-
-/**
- * Your TopVotedCandidate object will be instantiated and called as such:
- * TopVotedCandidate obj = new TopVotedCandidate(persons, times);
- * int param_1 = obj.q(t);
- */
diff --git a/Contests/Weekly Contest 103/Smallest Range I.java b/Contests/Weekly Contest 103/Smallest Range I.java
deleted file mode 100644
index b93686ed..00000000
--- a/Contests/Weekly Contest 103/Smallest Range I.java	
+++ /dev/null
@@ -1,7 +0,0 @@
-class Solution {
-
-    public static int smallestRangeI(int[] A, int K) {
-        Arrays.sort(A);
-        return Math.max((A[A.length-1] - K) - (A[0] + K), 0);
-    }
-}
diff --git a/Contests/Weekly Contest 103/Smallest Range II.java b/Contests/Weekly Contest 103/Smallest Range II.java
deleted file mode 100644
index 2ad7c801..00000000
--- a/Contests/Weekly Contest 103/Smallest Range II.java	
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution {
-    public int smallestRangeII(int[] A, int K) {
-        int N = A.length;
-        Arrays.sort(A);
-        int ans = A[N-1] - A[0];
-
-        for (int i=0; i<N-1; i++) {
-            int max = Math.max(A[N-1] - K, A[i] + K);
-            int min = Math.min(A[0] + K, A[i+1] - K);
-
-            ans = Math.min(ans, max - min);
-        }
-
-        return ans;
-    }
-}
diff --git a/Contests/Weekly Contest 104/Partition Array into Disjoint Intervals.java b/Contests/Weekly Contest 104/Partition Array into Disjoint Intervals.java
deleted file mode 100644
index ecd4199e..00000000
--- a/Contests/Weekly Contest 104/Partition Array into Disjoint Intervals.java	
+++ /dev/null
@@ -1,25 +0,0 @@
-class Solution {
-    public static int partitionDisjoint(int[] A) {
-        int[] min = new int[A.length];
-        int minVal = Integer.MAX_VALUE;
-
-        for (int i=A.length-1; i>=0; i--) {
-            minVal = Math.min(minVal, A[i]);
-            min[i] = minVal;
-        }
-
-        int[] max = new int[A.length];
-        int maxVal = Integer.MIN_VALUE;
-
-        for (int i=0; i<A.length; i++) {
-            maxVal = Math.max(maxVal, A[i]);
-            max[i] = maxVal;
-
-            if (i < A.length-1 && max[i] <= min[i+1]) {
-                return i + 1;
-            }
-        }
-
-        return A.length;
-    }
-}
diff --git a/Contests/Weekly Contest 104/Word Subsets.java b/Contests/Weekly Contest 104/Word Subsets.java
deleted file mode 100644
index 05474efd..00000000
--- a/Contests/Weekly Contest 104/Word Subsets.java	
+++ /dev/null
@@ -1,58 +0,0 @@
-class Solution {
-    public static List<String> wordSubsets(String[] A, String[] B) {
-        Map<String, Map<Character, Integer>> map1 = getMap(A);
-
-        Map<Character, Integer> map2 = new HashMap<>();
-        for (String s : B) {
-            Map<Character, Integer> temp = new HashMap<>();
-            char[] tempChar = s.toCharArray();
-
-            for (char c : tempChar) {
-                temp.put(c, temp.getOrDefault(c, 0) + 1);
-            }
-
-            for (Map.Entry<Character, Integer> entry : temp.entrySet()) {
-                int val1 = entry.getValue();
-                int val2 = map2.getOrDefault(entry.getKey(), 0);
-
-                map2.put(entry.getKey(), Math.max(val1, val2));
-            }
-        }
-
-        List<String> ans = new ArrayList<>();
-
-        for (String s : A) {
-            boolean flag = true;
-            Map<Character, Integer> temp2 = map1.get(s);
-
-            for (Map.Entry<Character, Integer> entry : map2.entrySet()) {
-                if (!(temp2.containsKey(entry.getKey()) && temp2.get(entry.getKey()) >= entry.getValue())) {
-                    flag = false;
-                    break;
-                }
-            }
-
-            if (flag) {
-                ans.add(s);
-            }
-        }
-
-        return ans;
-    }
-
-    private static Map<String, Map<Character, Integer>> getMap(String[] A) {
-        Map<String, Map<Character, Integer>> map = new HashMap<>();
-
-        for (String a : A) {
-            char[] arr = a.toCharArray();
-            Map<Character, Integer> charMap = new HashMap<>();
-            for (char c : arr) {
-                charMap.put(c, charMap.getOrDefault(c, 0) + 1);
-            }
-
-            map.put(a, charMap);
-        }
-
-        return map;
-    }
-}
diff --git a/Contests/Weekly Contest 104/X of a Kind in a Deck of Cards.java b/Contests/Weekly Contest 104/X of a Kind in a Deck of Cards.java
deleted file mode 100644
index 327fc563..00000000
--- a/Contests/Weekly Contest 104/X of a Kind in a Deck of Cards.java	
+++ /dev/null
@@ -1,47 +0,0 @@
-class Solution {
-    public static boolean hasGroupsSizeX(int[] deck) {
-        Map<Integer, Integer> map = new HashMap<>();
-
-        for (int card: deck) {
-            map.put(card, map.getOrDefault(card, 0) + 1);
-        }
-
-        int X = -1;
-
-        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            if (entry.getValue() < 2) {
-                return false;
-            }
-
-            if (X == -1) {
-                X = entry.getValue();
-            }
-            else {
-                X = findGCD(X, entry.getValue());
-            }
-        }
-
-        if (X == 1) {
-            return false;
-        }
-
-        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            if (entry.getValue() % X != 0) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    private static int findGCD(int n1, int n2) {
-        while(n1 != n2) {
-            if(n1 > n2)
-                n1 -= n2;
-            else
-                n2 -= n1;
-        }
-
-        return n1;
-    }
-}
diff --git a/Contests/Weekly Contest 105/Maximum Sum Circular Subarray.java b/Contests/Weekly Contest 105/Maximum Sum Circular Subarray.java
deleted file mode 100644
index bdc17368..00000000
--- a/Contests/Weekly Contest 105/Maximum Sum Circular Subarray.java	
+++ /dev/null
@@ -1,28 +0,0 @@
-class Solution {
-    public static  int maxSubarraySumCircular(int[] A) {
-        int max = kadane(A);
-        int wrap = 0;
-        
-        for(int i=0; i < A.length; i++) {
-            wrap = wrap+A[i];
-            A[i] *= -1;
-        }
-        
-        wrap = wrap + kadane(A);
-        
-        return Math.abs(wrap) < Math.abs(max) ? max : wrap;
-    }
-
-
-    private static int kadane(int[] a){
-        int maxSoFar=a[0];
-        int maxGlobal =a[0];
-        
-        for(int i=1; i<a.length; i++) {
-            maxSoFar = Math.max(a[i], maxSoFar + a[i]);
-            maxGlobal =Math.max(maxGlobal, maxSoFar);
-        }
-        
-        return maxGlobal;
-    }
-}
diff --git a/Contests/Weekly Contest 105/Reverse Only Letters.java b/Contests/Weekly Contest 105/Reverse Only Letters.java
deleted file mode 100644
index 7ba65e1b..00000000
--- a/Contests/Weekly Contest 105/Reverse Only Letters.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-class Solution {
-    public static String reverseOnlyLetters(String S) {
-        char[] chars = S.toCharArray();
-        int start = 0;
-        int end = chars.length - 1;
-
-        while (start < end) {
-            if (Character.isLetter(chars[start]) && Character.isLetter(chars[end])) {
-                char temp = chars[start];
-                chars[start] = chars[end];
-                chars[end] = temp;
-
-                start++;
-                end--;
-            }
-            else if (Character.isLetter(chars[start]) && !Character.isLetter(chars[end])) {
-                end--;
-            }
-            else if (!Character.isLetter(chars[start]) && Character.isLetter(chars[end])) {
-                start++;
-            }
-            else {
-                start++;
-                end--;
-            }
-        }
-
-        return String.valueOf(chars);
-    }
-}
diff --git a/Contests/Weekly Contest 106/3Sum With Multiplicity.java b/Contests/Weekly Contest 106/3Sum With Multiplicity.java
deleted file mode 100644
index 8cd1dc16..00000000
--- a/Contests/Weekly Contest 106/3Sum With Multiplicity.java	
+++ /dev/null
@@ -1,31 +0,0 @@
-class Solution {
-    public int threeSumMulti(int[] A, int target) {
-        int div = 1000000007;
-        int count = 0;
-        for (int i=0; i<A.length; i++) {
-            int temp = getPairsCount(A.length, target-A[i], A, i+1);
-            count = (count+temp)%div;
-        }
-        return count;
-    }
-
-    public int getPairsCount(int n, int sum, int[] arr, int start) {
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int i=start; i<n; i++) {
-            map.put(arr[i], map.getOrDefault(arr[i], 0)+1);
-        }
-
-        int count = 0;
-        for (int i=start; i<n; i++) {
-            if(map.get(sum-arr[i]) != null) {
-                count += map.get(sum - arr[i]);
-            }
-
-            if (sum-arr[i] == arr[i]) {
-                count--;
-            }
-        }
-
-        return count/2;
-    }
-}
diff --git a/Contests/Weekly Contest 106/Minimum Add to Make Parentheses Valid.java b/Contests/Weekly Contest 106/Minimum Add to Make Parentheses Valid.java
deleted file mode 100644
index 4022ac2d..00000000
--- a/Contests/Weekly Contest 106/Minimum Add to Make Parentheses Valid.java	
+++ /dev/null
@@ -1,24 +0,0 @@
-class Solution {
-    public int minAddToMakeValid(String S) {
-        Stack<Character> open = new Stack<>();
-        int count = 0;
-
-        for (char c : S.toCharArray()) {
-            if (c == '(') {
-                open.push(c);
-            }
-            else {
-                if (open.empty()) {
-                    count++;
-                }
-                else {
-                    open.pop();
-                }
-            }
-        }
-
-        count += open.size();
-
-        return count;
-    }
-}
diff --git a/Contests/Weekly Contest 106/Sort Array By Parity II.java b/Contests/Weekly Contest 106/Sort Array By Parity II.java
deleted file mode 100644
index 1289a2e4..00000000
--- a/Contests/Weekly Contest 106/Sort Array By Parity II.java	
+++ /dev/null
@@ -1,35 +0,0 @@
-class Solution {
-    public int[] sortArrayByParityII(int[] A) {
-        int[] ans = new int[A.length];
-        int[] odd = new int[A.length/2];
-        int[] even = new int[A.length/2];
-
-        int i = 0;
-        int j = 0;
-        int k = 0;
-
-        while (k < A.length) {
-            if (A[k]%2 == 0) {
-                even[j++] = A[k++];
-            }
-            else {
-                odd[i++] = A[k++];
-            }
-        }
-        
-        i = 0;
-        j = 0;
-        k = 0;
-
-        while (k < ans.length) {
-            if (k%2 == 0) {
-                ans[k++] = even[j++];
-            }
-            else {
-                ans[k++] = odd[i++];
-            }
-        }
-
-        return ans;
-    }
-}
diff --git a/Contests/Weekly Contest 107/Flip String to Monotone Increasing.java b/Contests/Weekly Contest 107/Flip String to Monotone Increasing.java
deleted file mode 100644
index 6f98ab13..00000000
--- a/Contests/Weekly Contest 107/Flip String to Monotone Increasing.java	
+++ /dev/null
@@ -1,27 +0,0 @@
-class Solution {
-    public static int minFlipsMonoIncr(String S) {
-        int zeroCount = 0;
-        int flipCount = 0;
-        int oneCount = 0;
-        
-        for (char c : S.toCharArray()) {
-            if (c == '0') {
-                if (oneCount == 0) {
-                    continue;
-                }
-                else {
-                    flipCount++;
-                }
-            }
-            else {
-                oneCount++;
-            }
-            
-            if (flipCount > oneCount) {
-                flipCount = oneCount;
-            }
-        }
-        
-        return flipCount;
-    }
-}
diff --git a/Contests/Weekly Contest 107/Long Pressed Name.java b/Contests/Weekly Contest 107/Long Pressed Name.java
deleted file mode 100644
index 5bf9065a..00000000
--- a/Contests/Weekly Contest 107/Long Pressed Name.java	
+++ /dev/null
@@ -1,29 +0,0 @@
-class Solution {
-    public static boolean isLongPressedName(String name, String typed) {
-        int slow = 0;
-        int fast = 0;
-
-        while (slow < name.length() && fast < typed.length()) {
-            if (name.charAt(slow) == typed.charAt(fast)) {
-                slow++;
-                fast++;
-            }
-            else if (fast > 0 && typed.charAt(fast) == typed.charAt(fast-1)) {
-                fast++;
-            }
-            else {
-                return false;
-            }
-        }
-
-        while (fast < typed.length()) {
-            if (typed.charAt(fast) != typed.charAt(fast-1)) {
-                return false;
-            }
-
-            fast++;
-        }
-
-        return slow == name.length();
-    }
-}
diff --git a/Contests/Weekly Contest 108/Binary Subarrays With Sum.java b/Contests/Weekly Contest 108/Binary Subarrays With Sum.java
deleted file mode 100644
index 37cc0a30..00000000
--- a/Contests/Weekly Contest 108/Binary Subarrays With Sum.java	
+++ /dev/null
@@ -1,18 +0,0 @@
-class Solution {
-    public int numSubarraysWithSum(int[] A, int S) {
-        Map<Integer, Integer> c = new HashMap<>();
-
-        c.put(0, 1);
-
-        int psum = 0;
-        int res = 0;
-
-        for (int i : A) {
-            psum += i;
-            res += c.getOrDefault(psum - S, 0);
-            c.put(psum, c.getOrDefault(psum, 0)+1);
-        }
-
-        return res;
-    }
-}
diff --git a/Contests/Weekly Contest 108/Minimum Falling Path Sum.java b/Contests/Weekly Contest 108/Minimum Falling Path Sum.java
deleted file mode 100644
index 056d9501..00000000
--- a/Contests/Weekly Contest 108/Minimum Falling Path Sum.java	
+++ /dev/null
@@ -1,37 +0,0 @@
-class Solution {
-    public int minFallingPathSum(int[][] A) {
-        int n = A.length;
-        int[][] dp = new int[n][n];
-
-        for (int[] arr : dp) {
-            Arrays.fill(arr, Integer.MAX_VALUE);
-        }
-
-        for (int i=0; i<n; i++) {
-            for (int j=0; j<n; j++) {
-                if (i == 0) {
-                    dp[i][j] = A[i][j];
-                }
-                else {
-                    dp[i][j] = dp[i-1][j];
-                    if (j-1 >= 0) {
-                        dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1]);
-                    }
-
-                    if (j+1 < A.length) {
-                        dp[i][j] = Math.min(dp[i][j], dp[i-1][j+1]);
-                    }
-
-                    dp[i][j] += A[i][j];
-                }
-            }
-        }
-
-        int minVal = Integer.MAX_VALUE;
-        for (int num : dp[n-1]) {
-            minVal = Math.min(minVal, num);
-        }
-
-        return minVal;
-    }
-}
diff --git a/Contests/Weekly Contest 108/Unique Email Addresses.java b/Contests/Weekly Contest 108/Unique Email Addresses.java
deleted file mode 100644
index b234df03..00000000
--- a/Contests/Weekly Contest 108/Unique Email Addresses.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-    public int numUniqueEmails(String[] emails) {
-        Set<String> set = new HashSet<>();
-
-        for (String email : emails) {
-            String localName = email.split("@")[0];
-            String domainName = email.split("@")[1];
-
-            localName = localName.replace(".", "");
-            int idx = localName.indexOf('+');
-            if (idx != -1) {
-                localName = localName.substring(0, idx);
-            }
-
-            set.add(localName+"@"+domainName);
-        }
-
-        return set.size();
-    }
-}
diff --git a/Contests/Weekly Contest 109/Knight Dialer.java b/Contests/Weekly Contest 109/Knight Dialer.java
deleted file mode 100644
index 3626b968..00000000
--- a/Contests/Weekly Contest 109/Knight Dialer.java	
+++ /dev/null
@@ -1,25 +0,0 @@
-class Solution {
-    public int knightDialer(int N) {
-        int MOD = 1000000007;
-        long[] counts = new long[10];
-        Arrays.fill(counts, 1);
-        long[] temp;
-
-        for (int i=1; i<=N-1; i++) {
-            temp = counts.clone();
-
-            counts[0] = (temp[4] + temp[6]) % MOD;
-            counts[1] = (temp[6] + temp[8]) % MOD;
-            counts[2] = (temp[7] + temp[9]) % MOD;
-            counts[3] = (temp[4] + temp[8]) % MOD;
-            counts[4] = (temp[3] + temp[9] + temp[0]) % MOD;
-            counts[5] = 0;
-            counts[6] = (temp[1] + temp[7] + temp[0]) % MOD;
-            counts[7] = (temp[2] + temp[6]) % MOD;
-            counts[8] = (temp[1] + temp[3]) % MOD;
-            counts[9] = (temp[2] + temp[4]) % MOD;
-        }
-
-        return (int)(Arrays.stream(counts).sum()%MOD);
-    }
-}
diff --git a/Contests/Weekly Contest 109/Number of Recent Calls.java b/Contests/Weekly Contest 109/Number of Recent Calls.java
deleted file mode 100644
index 097b56c8..00000000
--- a/Contests/Weekly Contest 109/Number of Recent Calls.java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class RecentCounter {
-
-    Queue<Integer> queue;
-    public RecentCounter() {
-        queue = new LinkedList<>();
-    }
-
-    public int ping(int t) {
-        while (!queue.isEmpty() && t - queue.peek() > 3000) {
-            queue.remove();
-        }
-
-        queue.add(t);
-
-        return queue.size();
-    }
-}
-
-/**
- * Your RecentCounter object will be instantiated and called as such:
- * RecentCounter obj = new RecentCounter();
- * int param_1 = obj.ping(t);
- */
diff --git a/Contests/Weekly Contest 110/Distinct Subsequence II.java b/Contests/Weekly Contest 110/Distinct Subsequence II.java
deleted file mode 100644
index af605fb7..00000000
--- a/Contests/Weekly Contest 110/Distinct Subsequence II.java	
+++ /dev/null
@@ -1,12 +0,0 @@
-class Solution {
-    public int distinctSubseqII(String s) {
-        long[] occurenceIndx = new long[26];
-        long MOD = 1000000007;
-        
-        for (char c : s.toCharArray()) {
-            occurenceIndx[c - 'a'] = Arrays.stream(occurenceIndx).sum() % MOD + 1;
-        }
-
-        return (int) (Arrays.stream(occurenceIndx).sum() % MOD);
-    }
-}
diff --git a/Contests/Weekly Contest 110/Minimum Area Rectangle.java b/Contests/Weekly Contest 110/Minimum Area Rectangle.java
deleted file mode 100644
index be63eb90..00000000
--- a/Contests/Weekly Contest 110/Minimum Area Rectangle.java	
+++ /dev/null
@@ -1,32 +0,0 @@
-class Solution {
-    public int minAreaRect(int[][] points) {
-        Map<Integer, List<Integer>> rows = new TreeMap<>();
-        for (int[] point : points) {
-            int x = point[0];
-            int y = point[1];
-            rows.computeIfAbsent(x , z -> new ArrayList<>()).add(y);
-        }
-
-        int ans = Integer.MAX_VALUE;
-        Map<Integer, Integer> lastIdx = new HashMap<>();
-        for (int key : rows.keySet()) {
-            List<Integer> row = rows.get(key);
-            Collections.sort(row);
-
-            for (int i=0; i<row.size(); i++) {
-                for (int j=i+1; j<row.size(); j++) {
-                    int y1 = row.get(i);
-                    int y2 = row.get(j);
-                    int code = 40001 * y1 + y2;
-                    if (lastIdx.containsKey(code)) {
-                        ans = Math.min(ans, (key - lastIdx.get(code)) * (y2 - y1));
-                    }
-                    
-                    lastIdx.put(code, key);
-                }
-            }
-        }
-
-        return ans < Integer.MAX_VALUE ? ans : 0;
-    }
-}
diff --git a/Contests/Weekly Contest 110/Range Sum of BST.java b/Contests/Weekly Contest 110/Range Sum of BST.java
deleted file mode 100644
index 2e03c954..00000000
--- a/Contests/Weekly Contest 110/Range Sum of BST.java	
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public int sum;
-    public int rangeSumBST(TreeNode root, int L, int R) {
-        sum = 0;
-        rangeSumBSTHelper(root, L, R);
-        
-        return sum;
-    }
-    
-    private void rangeSumBSTHelper(TreeNode root, int low, int high) {
-        if (root == null) {
-            return;
-        }
-        
-        if (root.val >= low && root.val <= high) {
-            sum += root.val;
-            rangeSumBSTHelper(root.right, low, high);
-            rangeSumBSTHelper(root.left, low, high);
-        }
-        else {
-            if (root.val < low) {
-                rangeSumBSTHelper(root.right, low, high);
-            }
-
-            if (root.val > high) {
-                rangeSumBSTHelper(root.left, low, high);
-            }
-        }
-    }
-}
diff --git a/Contests/Weekly Contest 110/Reorder Log Files.java b/Contests/Weekly Contest 110/Reorder Log Files.java
deleted file mode 100644
index 6e2d505c..00000000
--- a/Contests/Weekly Contest 110/Reorder Log Files.java	
+++ /dev/null
@@ -1,53 +0,0 @@
-class Solution {
-    public String[] reorderLogFiles(String[] logs) {
-        List<String> letterLogs = new ArrayList<>();
-        List<String> digitLogs = new ArrayList<>();
-
-        for (String log : logs) {
-            if(Character.isDigit(log.split("\\s+")[1].charAt(0))) {
-                digitLogs.add(log);
-            }
-            else {
-                letterLogs.add(log);
-            }
-        }
-
-        Collections.sort(letterLogs, new Comparator<String>() {
-            @Override
-            public int compare(String o1, String o2) {
-                String[] s1 = o1.split("\\s+");
-                String[] s2 = o2.split("\\s+");
-
-                StringBuilder sb1 = new StringBuilder();
-                StringBuilder sb2 = new StringBuilder();
-
-                for (int i=1; i<s1.length; i++) {
-                    sb1.append(s1[i]).append(" ");
-                }
-
-                for (int i=1; i<s2.length; i++) {
-                    sb2.append(s2[i]).append(" ");
-                }
-
-                if (sb1.toString().compareTo(sb2.toString()) == 0) {
-                    return s1[0].compareTo(s2[0]);
-                }
-
-                return sb1.toString().compareTo(sb2.toString());
-            }
-        });
-
-        String[] ans = new String[logs.length];
-
-        int i = 0;
-        for (String log : letterLogs) {
-            ans[i++] = log;
-        }
-
-        for (String log : digitLogs) {
-            ans[i++] = log;
-        }
-
-        return ans;
-    }
-}
diff --git a/Contests/Weekly Contest 111/DI String Match.java b/Contests/Weekly Contest 111/DI String Match.java
deleted file mode 100644
index a5fa0d77..00000000
--- a/Contests/Weekly Contest 111/DI String Match.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-    public int[] diStringMatch(String S) {
-        int[] ans = new int[S.length() + 1];
-
-        int iStart = 0;
-        int dStart = S.length();
-
-        for (int i=0; i<S.length(); i++) {
-            if (S.charAt(i) == 'I') {
-                ans[i] = iStart++;
-            }
-            else {
-                ans[i] = dStart--;
-            }
-        }
-
-        ans[ans.length - 1] = dStart == 0 ? iStart : dStart;
-
-        return ans;
-    }
-}
diff --git a/Contests/Weekly Contest 111/Delete Columns to Make Sorted.java b/Contests/Weekly Contest 111/Delete Columns to Make Sorted.java
deleted file mode 100644
index c88f30f5..00000000
--- a/Contests/Weekly Contest 111/Delete Columns to Make Sorted.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-    public int minDeletionSize(String[] A) {
-        int delCount = 0;
-        for (int i=0;i<A[0].length();i++) {
-            char prev = '-';
-            for (int j=0; j<A.length; j++) {
-                if (j == 0) {
-                    prev = A[j].charAt(i);
-                }
-                else {
-                    if (A[j].charAt(i) < prev) {
-                        delCount++;
-                        break;
-                    }
-
-                    prev = A[j].charAt(i);
-                }
-            }
-        }
-        return delCount;
-    }
-}
diff --git a/Contests/Weekly Contest 111/Valid Mountain Array.java b/Contests/Weekly Contest 111/Valid Mountain Array.java
deleted file mode 100644
index 61270a84..00000000
--- a/Contests/Weekly Contest 111/Valid Mountain Array.java	
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution {
-    public boolean validMountainArray(int[] A) {
-        int i = 0;
-        int j = A.length - 1;
-        int n = A.length - 1;
-        while (i + 1 < n && A[i] < A[i+1]) {
-            i++;
-        }
-        
-        while (j > 0 && A[j] < A[j-1]) {
-            j--;
-        }
-        
-        return i > 0 && i == j && j < n;
-    }
-}
diff --git a/Contests/Weekly Contest 112/Bag of Tokens.java b/Contests/Weekly Contest 112/Bag of Tokens.java
deleted file mode 100644
index 610c54e4..00000000
--- a/Contests/Weekly Contest 112/Bag of Tokens.java	
+++ /dev/null
@@ -1,31 +0,0 @@
-class Solution {
-    public int bagOfTokensScore(int[] tokens, int P) {
-        Arrays.sort(tokens);
-        int start = 0;
-        int end = tokens.length - 1;
-        int numOfPoints = 0;
-        int maxPoint = 0;
-
-        while (start <= end) {
-            if (P >= tokens[start]) {
-                P -= tokens[start];
-                start++;
-                numOfPoints++;
-            }
-            else {
-                if (numOfPoints > 0) {
-                    numOfPoints--;
-                    P += tokens[end];
-                    end--;
-                }
-                else {
-                    break;
-                }
-            }
-
-            maxPoint = Math.max(numOfPoints, maxPoint);
-        }
-
-        return maxPoint;
-    }
-}
diff --git a/Contests/Weekly Contest 112/Minimum Increment to Make Array Unique.java b/Contests/Weekly Contest 112/Minimum Increment to Make Array Unique.java
deleted file mode 100644
index 983f6d29..00000000
--- a/Contests/Weekly Contest 112/Minimum Increment to Make Array Unique.java	
+++ /dev/null
@@ -1,19 +0,0 @@
-class Solution {
-    public int minIncrementForUnique(int[] arr) {
-        int count = 0;
-
-        Arrays.sort(arr);
-        int previous = Integer.MIN_VALUE;
-
-        for (int i=0; i<arr.length; i++) {
-            if (previous != Integer.MIN_VALUE && previous >= arr[i]) {
-                count += previous - arr[i] == 0 ? 1 : previous + 1 - arr[i];
-                arr[i] = previous + 1;
-            }
-
-            previous = arr[i];
-        }
-
-        return count;
-    }
-}
diff --git a/Contests/Weekly Contest 112/Most Stones Removed with Same Row or Column.java b/Contests/Weekly Contest 112/Most Stones Removed with Same Row or Column.java
deleted file mode 100644
index 916ceeb5..00000000
--- a/Contests/Weekly Contest 112/Most Stones Removed with Same Row or Column.java	
+++ /dev/null
@@ -1,44 +0,0 @@
-class Solution {
-    public int count = 0;
-    public int removeStones(int[][] stones) {
-        Map<String, String> map = new HashMap<>();
-        count = stones.length;
-
-        for (int[] stone : stones) {
-            String key = stone[0] + " " + stone[1];
-            map.put(key, key);
-        }
-
-        for (int[] stone : stones) {
-            String key = stone[0] + " " + stone[1];
-            for (int[] stone2 : stones) {
-                if (stone2[0] == stone[0] || stone2[1] == stone[1]) {
-                    String key2 = stone2[0] + " " + stone2[1];
-                    union(map, key, key2);
-                }
-            }
-        }
-
-        return stones.length - count;
-    }
-
-    private void union(Map<String, String> map, String s1, String s2) {
-        String r1 = find(map, s1);
-        String r2 = find(map, s2);
-
-        if (r1.equals(r2)) {
-            return;
-        }
-
-        map.put(r1, r2);
-        count--;
-    }
-
-    private String find(Map<String, String> map, String s) {
-        if (!map.get(s).equals(s)) {
-            map.put(s, find(map, map.get(s)));
-        }
-
-        return map.get(s);
-    }
-}
diff --git a/Contests/Weekly Contest 112/Validate Stack Sequences.java b/Contests/Weekly Contest 112/Validate Stack Sequences.java
deleted file mode 100644
index c90d9957..00000000
--- a/Contests/Weekly Contest 112/Validate Stack Sequences.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-class Solution {
-    public boolean validateStackSequences(int[] pushed, int[] popped) {
-        Stack<Integer> stack = new Stack<>();
-        
-        int i = 0;
-        int j = 0;
-        
-        while (i < pushed.length || j < popped.length) {
-            if (stack.isEmpty() || stack.peek() != popped[j]) {
-                if (i < pushed.length) {
-                    stack.push(pushed[i++]);
-                }
-                else {
-                    return false;
-                }
-            }
-            else {
-                if (j < popped.length && stack.peek() == popped[j]) {
-                    stack.pop();
-                    j++;
-                }
-                else {
-                    return false;
-                }
-            }
-        }
-        
-        return true;
-    }
-}
diff --git a/Contests/Weekly Contest 113/Flip Equivalent Binary Trees.java b/Contests/Weekly Contest 113/Flip Equivalent Binary Trees.java
deleted file mode 100644
index 9b025770..00000000
--- a/Contests/Weekly Contest 113/Flip Equivalent Binary Trees.java	
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
-        if (root1 == null) {
-            return root2 == null;
-        }
-        
-        if (root2 == null) {
-            return root1 == null;
-        }
-        
-        if (root1.val != root2.val) {
-            return false;
-        }
-        
-        return (flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right) ||
-                flipEquiv(root1.left, root2.right) && flipEquiv(root1.right, root2.left));
-    }
-}
diff --git a/Contests/Weekly Contest 113/Largest Time for Given Digits.java b/Contests/Weekly Contest 113/Largest Time for Given Digits.java
deleted file mode 100644
index 7a645e07..00000000
--- a/Contests/Weekly Contest 113/Largest Time for Given Digits.java	
+++ /dev/null
@@ -1,57 +0,0 @@
-class Solution {
-    public String largestTimeFromDigits(int[] arr) {
-        List<String> permutations = permuteUnique(arr);
-        String maxStr = "";
-
-        for (String str : permutations) {
-            if (isValid(str)) {
-                if (maxStr.length() == 0) {
-                    maxStr = str;
-                }
-                else if (maxStr.compareTo(str) < 0) {
-                    maxStr = str;
-                }
-            }
-        }
-
-        return maxStr.length() > 0 ? maxStr.substring(0, 2) + ":" + maxStr.substring(2) : maxStr;
-    }
-
-    private boolean isValid(String str) {
-        int left = Integer.parseInt(str.substring(0, 2));
-        int right = Integer.parseInt(str.substring(2));
-
-        return left >= 0 && left <= 23 && right >= 0 && right <= 59;
-    }
-
-    private List<String> permuteUnique(int[] nums) {
-        List<String> ans = new ArrayList<>();
-        Arrays.sort(nums);
-        permuteHelper(nums, new ArrayList<>(), ans, new boolean[nums.length]);
-        return new ArrayList<>(ans);
-    }
-
-    private void permuteHelper(int[] nums, List<Integer> list, List<String> ans, boolean[] used) {
-        if (list.size() == nums.length) {
-            ans.add(list.stream().map(n -> String.valueOf(n)).collect(Collectors.joining("")));
-        }
-        else {
-            for (int i=0; i<nums.length; i++) {
-                // Choose
-                if (used[i] || (i > 0 && nums[i] == nums[i-1] && !used[i-1])) {
-                    continue;
-                }
-
-                used[i] = true;
-                list.add(nums[i]);
-
-                // Explore
-                permuteHelper(nums, list, ans, used);
-
-                // Un-choose
-                used[i] = false;
-                list.remove(list.size()-1);
-            }
-        }
-    }
-}
diff --git a/Contests/Weekly Contest 113/Reveal Cards In Increasing Order.java b/Contests/Weekly Contest 113/Reveal Cards In Increasing Order.java
deleted file mode 100644
index b2aed465..00000000
--- a/Contests/Weekly Contest 113/Reveal Cards In Increasing Order.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-    public int[] deckRevealedIncreasing(int[] deck) {
-        int n = deck.length;
-        int[] ans = new int[n];
-        Deque<Integer> deque = new LinkedList<>();
-        Arrays.sort(deck);
-        deque.addFirst(deck[n-1]);
-        
-        for (int i=n-2; i>=0; i--) {
-            int temp = deque.removeLast();
-            deque.addFirst(temp);
-            deque.addFirst(deck[i]);
-        }
-        
-        int idx = 0;
-        while (!deque.isEmpty()) {
-            ans[idx++] = deque.pollFirst();
-        }
-        
-        return ans;
-    }
-}
diff --git a/Contests/Weekly Contest 115/Check Completeness of a Binary Tree.java b/Contests/Weekly Contest 115/Check Completeness of a Binary Tree.java
deleted file mode 100644
index 33573b90..00000000
--- a/Contests/Weekly Contest 115/Check Completeness of a Binary Tree.java	
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public boolean isCompleteTree(TreeNode root) {
-        if (root == null) {
-            return true;
-        }
-        int numOfNodes = getNumOfNodes(root);
-        return isCompleteTreeHelper(root, 0, numOfNodes);
-    }
-    
-    private boolean isCompleteTreeHelper(TreeNode root, int curr, int numOfNodes) {
-        if (root == null) {
-            return true;
-        }
-        
-        if (curr >= numOfNodes) {
-            return false;
-        }
-        
-        return isCompleteTreeHelper(root.left, 2 * curr + 1, numOfNodes) && isCompleteTreeHelper(root.right, 2 * curr + 2, numOfNodes);
-    }
-    
-    private int getNumOfNodes(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        
-        return 1 + getNumOfNodes(root.left) + getNumOfNodes(root.right);
-    }
-}
diff --git a/Contests/Weekly Contest 126/Check If Word Is Valid After Substitutions.java b/Contests/Weekly Contest 126/Check If Word Is Valid After Substitutions.java
deleted file mode 100644
index dc030951..00000000
--- a/Contests/Weekly Contest 126/Check If Word Is Valid After Substitutions.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-    public boolean isValid(String S) {
-        Stack<Character> stack = new Stack<>();
-        for (char c : S.toCharArray()) {
-            if (c == 'a' || c == 'b') {
-                stack.push(c);            
-            }
-            else {
-                if (stack.isEmpty() || stack.pop() != 'b') {
-                    return false;
-                }
-                
-                if (stack.isEmpty() || stack.pop() != 'a') {
-                    return false;
-                }
-            }
-        }
-        
-        return stack.size() == 0;
-    }
-}
diff --git a/Contests/Weekly Contest 126/Find Common Characters.java b/Contests/Weekly Contest 126/Find Common Characters.java
deleted file mode 100644
index b0fea474..00000000
--- a/Contests/Weekly Contest 126/Find Common Characters.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-class Solution {
-    public List<String> commonChars(String[] A) {
-        int[] mainCounter = new int[26];
-        Arrays.fill(mainCounter, Integer.MAX_VALUE);
-
-        for (String str : A) {
-            int[] counter = new int[26];
-            for (char c : str.toCharArray()) {
-                counter[c - 'a']++;
-            }
-
-            for (int i = 0; i < 26; i++) {
-                mainCounter[i] = Math.min(mainCounter[i], counter[i]);
-            }
-        }
-
-        List<String> list = new ArrayList<>();
-
-        for (int i = 0; i < 26; i++) {
-            int count = mainCounter[i];
-            char c = (char) (97 + i);
-
-            while (count-- > 0) {
-                list.add(String.valueOf(c));
-            }
-        }
-
-        return list;
-    }
-}
diff --git a/Contests/Weekly Contest 126/Max Consecutive Ones III.java b/Contests/Weekly Contest 126/Max Consecutive Ones III.java
deleted file mode 100644
index 49349bd8..00000000
--- a/Contests/Weekly Contest 126/Max Consecutive Ones III.java	
+++ /dev/null
@@ -1,31 +0,0 @@
-class Solution {
-    public int longestOnes(int[] A, int K) {
-        int slow = 0;
-        int fast = 0;
-        int count = 0;
-        int end = A.length;
-        int maxLen = 0;
-
-        while (fast < end) {
-            if (A[fast] != 1) {
-                count++;
-            }
-
-            while (count > K && slow < end) {
-                if (A[slow] == 0) {
-                    count--;
-                }
-
-                slow++;
-            }
-
-            fast++;
-
-           if (fast - slow > maxLen) {
-               maxLen = fast - slow;
-           }
-        }
-
-        return maxLen;
-    }
-}
diff --git a/Contests/Weekly Contest 127/Clumsy Factorial.java b/Contests/Weekly Contest 127/Clumsy Factorial.java
deleted file mode 100644
index 391ede85..00000000
--- a/Contests/Weekly Contest 127/Clumsy Factorial.java	
+++ /dev/null
@@ -1,59 +0,0 @@
-class Solution {
-    public int clumsy(int N) {
-        if (N <= 1) {
-            return N;
-        }
-
-        char[] oper = {'*', '/', '+', '-'};
-        int idx = 0;
-
-        StringBuilder sb = new StringBuilder();
-        while (N > 0) {
-            sb.append(N).append(" ").append(oper[idx++]).append(" ");
-            if (idx > 3) {
-                idx = 0;
-            }
-
-            N--;
-        }
-
-        return basicCalculator(sb.toString().substring(0, sb.length() - 2));
-    }
-
-    private int basicCalculator(String s) {
-        int num = 0;
-        char sign = '+';
-        Stack<Integer> stack = new Stack<>();
-
-        for (int i = 0; i < s.length(); i++) {
-            if (Character.isDigit(s.charAt(i))) {
-                num = num * 10 + Character.getNumericValue(s.charAt(i));
-            }
-
-            if (!Character.isDigit(s.charAt(i)) && s.charAt(i) != ' ' || i == s.length() - 1) {
-                if (sign == '+') {
-                    stack.push(num);
-                }
-                else if (sign == '-') {
-                    stack.push(-num);
-                }
-                else if (sign == '*') {
-                    stack.push(stack.pop() * num);
-                }
-                else {
-                    stack.push(stack.pop() / num);
-                }
-
-                sign = s.charAt(i);
-                num = 0;
-            }
-        }
-
-        int res = 0;
-        while (!stack.isEmpty()) {
-            res += stack.pop();
-        }
-
-        return res;
-    }
-}
diff --git a/Contests/Weekly Contest 127/Construct Binary Search Tree from Preorder Traversal.java b/Contests/Weekly Contest 127/Construct Binary Search Tree from Preorder Traversal.java
deleted file mode 100644
index 276ff05d..00000000
--- a/Contests/Weekly Contest 127/Construct Binary Search Tree from Preorder Traversal.java	
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    int idx;
-    public TreeNode bstFromPreorder(int[] preorder) {
-        idx = 0;
-        return bstFromPreorderHelper(preorder, preorder[0], Integer.MIN_VALUE, Integer.MAX_VALUE);
-    }
-    
-    private TreeNode bstFromPreorderHelper(int[] preorder, int key, int min, int max) {
-        if (idx >= preorder.length) {
-            return null;
-        }
-        
-        TreeNode root = null;
-        
-        if (preorder[idx] > min && preorder[idx] < max) {
-            root = new TreeNode(key);
-            idx++;
-            
-            if (idx < preorder.length) {
-                root.left = bstFromPreorderHelper(preorder, preorder[idx], min, key);
-                
-                if (idx < preorder.length) {
-                    root.right = bstFromPreorderHelper(preorder, preorder[idx], key, max);
-                }
-            }
-        }
-        
-        return root;
-    }
-}
diff --git a/Contests/Weekly Contest 127/Maximize Sum Of Array After K Negations.java b/Contests/Weekly Contest 127/Maximize Sum Of Array After K Negations.java
deleted file mode 100644
index a4db5a84..00000000
--- a/Contests/Weekly Contest 127/Maximize Sum Of Array After K Negations.java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class Solution {
-    public int largestSumAfterKNegations(int[] A, int K) {
-        PriorityQueue<Integer> pq = new PriorityQueue<>();
-
-        for (int num : A) {
-            pq.add(num);
-        }
-
-        while (K-- > 0) {
-            int popped = pq.poll();
-            popped *= -1;
-
-            pq.add(popped);
-        }
-        
-        int sum = 0;
-        while (!pq.isEmpty()) {
-            sum += pq.poll();
-        }
-
-        return sum;
-    }
-}
diff --git a/Contests/Weekly Contest 127/Minimum Domino Rotations For Equal Row.java b/Contests/Weekly Contest 127/Minimum Domino Rotations For Equal Row.java
deleted file mode 100644
index c9908513..00000000
--- a/Contests/Weekly Contest 127/Minimum Domino Rotations For Equal Row.java	
+++ /dev/null
@@ -1,25 +0,0 @@
-class Solution {
-    public int minDominoRotations(int[] A, int[] B) {
-        int[] aCount = new int[7];
-        int[] bCount = new int[7];
-        int[] sameCount = new int[7];
-        
-        for (int i = 0; i < A.length; i++) {
-            if (A[i] == B[i]) {
-                sameCount[A[i]]++;
-            }
-            else {
-                aCount[A[i]]++;
-                bCount[B[i]]++;
-            }
-        }
-        
-        for (int i = 1; i <= 6; i++) {
-            if (aCount[i] + bCount[i] + sameCount[i] == A.length) {
-                return sameCount[i] == A.length ? 0 : Math.min(aCount[i], bCount[i]);
-            }
-        }
-        
-        return -1;
-    }
-}
diff --git a/Contests/Weekly Contest 129/Best Sightseeing Pair.java b/Contests/Weekly Contest 129/Best Sightseeing Pair.java
deleted file mode 100644
index 173b530d..00000000
--- a/Contests/Weekly Contest 129/Best Sightseeing Pair.java	
+++ /dev/null
@@ -1,13 +0,0 @@
-class Solution {
-    public int maxScoreSightseeingPair(int[] A) {
-        int maxVal = 0;
-        int currMax = 0;
-        
-        for (int spot : A) {
-            maxVal = Math.max(maxVal, currMax + spot);
-            currMax = Math.max(spot, currMax) - 1;
-        }
-        
-        return maxVal;
-    }
-}
diff --git a/Contests/Weekly Contest 129/Binary String With Substrings Representing 1 To N.java b/Contests/Weekly Contest 129/Binary String With Substrings Representing 1 To N.java
deleted file mode 100644
index 179b0ec2..00000000
--- a/Contests/Weekly Contest 129/Binary String With Substrings Representing 1 To N.java	
+++ /dev/null
@@ -1,15 +0,0 @@
-class Solution {
-    public boolean queryString(String S, int N) {
-        
-        int num = N;
-        while (num >= N / 2) {
-            if (S.indexOf(Integer.toBinaryString(num)) == -1) {
-                return false;
-            }    
-            
-            num--;
-        }
-        
-        return true;
-    }
-}
diff --git a/Contests/Weekly Contest 129/Partition Array Into Three Parts With Equal Sum.java b/Contests/Weekly Contest 129/Partition Array Into Three Parts With Equal Sum.java
deleted file mode 100644
index b325e556..00000000
--- a/Contests/Weekly Contest 129/Partition Array Into Three Parts With Equal Sum.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-class Solution {
-    public boolean canThreePartsEqualSum(int[] A) {
-        int totalSum = 0;
-        for (int num : A) {
-            totalSum += num;
-        }
-        
-        if (totalSum % 3 != 0) {
-            return false;
-        }
-        
-        int singlePartitionSum = totalSum / 3;
-        int idx = 0;
-        int len = A.length;
-        int currPartitionSum = 0;
-        int count = 0;
-        
-        while (idx < len) {
-            currPartitionSum += A[idx];
-            if (currPartitionSum == singlePartitionSum) {
-                count++;
-                currPartitionSum = 0;
-            }
-            
-            idx++;
-        }
-        
-        return count == 3;
-    }
-}
diff --git a/Contests/Weekly Contest 129/Smallest Integer Divisible by K.java b/Contests/Weekly Contest 129/Smallest Integer Divisible by K.java
deleted file mode 100644
index aba8f5e3..00000000
--- a/Contests/Weekly Contest 129/Smallest Integer Divisible by K.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-    public int smallestRepunitDivByK(int K) {
-        if (K % 2 == 0 || K % 5 == 0) {
-            return -1;
-        }
-        
-        int rem = 0;
-        for (int i = 1; i <= K; i++) {
-            rem = (rem * 10 + 1) % K;
-            if (rem == 0) {
-                return i;
-            }
-        }
-        
-        return -1;
-    }
-}
diff --git a/Contests/Weekly Contest 131/Camelcase Matching.java b/Contests/Weekly Contest 131/Camelcase Matching.java
deleted file mode 100644
index 2313a4ee..00000000
--- a/Contests/Weekly Contest 131/Camelcase Matching.java	
+++ /dev/null
@@ -1,43 +0,0 @@
-class Solution {
-    public List<Boolean> camelMatch(String[] queries, String pattern) {
-        List<Boolean> ans = new ArrayList<>();
-        
-        for (String query : queries) {
-            ans.add(check(query, pattern));
-        }
-        
-        return ans;
-    }
-    
-    private boolean check(String query, String pattern) {
-        int qIdx = 0;
-        int pIdx = 0;
-        int qLen = query.length();
-        int pLen = pattern.length();
-        
-        while (qIdx < qLen && pIdx < pLen) {
-            if (query.charAt(qIdx) == pattern.charAt(pIdx)) {
-                qIdx++;
-                pIdx++;
-            }
-            else {
-                if (Character.isUpperCase(query.charAt(qIdx))) {
-                    return false;
-                }
-                else {
-                    qIdx++;
-                }
-            }
-        }
-        
-        while (qIdx < qLen) {
-            if (Character.isUpperCase(query.charAt(qIdx))) {
-                return false;
-            }
-            
-            qIdx++;
-        }
-        
-        return pIdx == pLen;
-    }
-}
diff --git a/Contests/Weekly Contest 131/Remove Outermost Parentheses.java b/Contests/Weekly Contest 131/Remove Outermost Parentheses.java
deleted file mode 100644
index dfff44c7..00000000
--- a/Contests/Weekly Contest 131/Remove Outermost Parentheses.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-    public String removeOuterParentheses(String S) {
-        StringBuilder sb = new StringBuilder();
-        int count = 0;
-        int prev = 0;
-        
-        for (int i = 0; i < S.length(); i++) {
-            if (S.charAt(i) == '(') {
-                count++;
-            }    
-            else {
-                count--;
-                if (count == 0) {
-                    sb.append(S.substring(prev + 1, i));
-                    prev = i + 1;
-                }
-            }
-        }
-        
-        return sb.toString();
-    }
-}
diff --git a/Contests/Weekly Contest 131/Sum of Root To Leaf Binary Numbers.java b/Contests/Weekly Contest 131/Sum of Root To Leaf Binary Numbers.java
deleted file mode 100644
index 8b630ccd..00000000
--- a/Contests/Weekly Contest 131/Sum of Root To Leaf Binary Numbers.java	
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public int sumRootToLeaf(TreeNode root) {
-        return dfsHelper(root, 0);
-    }
-    
-    private int MOD = 1000000007;
-    
-    private int dfsHelper(TreeNode root, int curr) {
-        if (root == null) {
-            return curr % MOD;
-        }
-        
-        curr = (curr * 2 + root.val) % MOD;
-        
-        if (root.left == null && root.right == null) {
-            return curr % MOD;
-        }
-        
-        int sum = 0;
-        
-        if (root.left != null) {
-            sum += dfsHelper(root.left, curr);
-        }
-        
-        if (root.right != null) {
-            sum += dfsHelper(root.right, curr);
-        }
-        
-        return sum % MOD;
-    }
-}
diff --git a/Contests/Weekly Contest 132/Divisor Game.java b/Contests/Weekly Contest 132/Divisor Game.java
deleted file mode 100644
index 8a30b499..00000000
--- a/Contests/Weekly Contest 132/Divisor Game.java	
+++ /dev/null
@@ -1,5 +0,0 @@
-class Solution {
-    public boolean divisorGame(int N) {
-        return N % 2 == 0;
-    }
-}
diff --git a/Contests/Weekly Contest 132/Longest Arithmetic Sequence.java b/Contests/Weekly Contest 132/Longest Arithmetic Sequence.java
deleted file mode 100644
index 15ad247d..00000000
--- a/Contests/Weekly Contest 132/Longest Arithmetic Sequence.java	
+++ /dev/null
@@ -1,35 +0,0 @@
-class Solution {
-    public int longestArithSeqLength(int[] A) {
-        if (A.length <= 1) {
-            return A.length;
-        }
-        
-        int res = 0;
-        HashMap<Integer, Integer>[] dp = new HashMap[A.length];
-        
-        for (int i = 0; i < A.length; i++) {
-            dp[i] = new HashMap<>();
-        }
-        
-        for (int i = 1; i < A.length; i++) {
-            int curr = A[i];
-            for (int j = 0; j < i; j++) {
-                int prev = A[j];
-                int diff = curr - prev;
-                
-                int len = 2;
-                
-                if (dp[j].containsKey(diff)) {
-                    len = dp[j].get(diff) + 1;
-                }
-                
-                int currLen = dp[i].getOrDefault(diff, 0);
-                dp[i].put(diff, Math.max(currLen, len));
-                
-                res = Math.max(res, dp[i].get(diff));
-            }
-        }
-        
-        return res;
-    }
-}
diff --git a/Contests/Weekly Contest 132/Maximum Difference Between Node and Ancestor.java b/Contests/Weekly Contest 132/Maximum Difference Between Node and Ancestor.java
deleted file mode 100644
index ea63ea0d..00000000
--- a/Contests/Weekly Contest 132/Maximum Difference Between Node and Ancestor.java	
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public int maxAncestorDiff(TreeNode root) {
-        return dfs(root, root.val, root.val);
-    }
-    
-    public int dfs(TreeNode root, int min, int max) {
-        if (root == null) {
-            return 0;
-        }
-        
-        int res = Math.max(max - root.val, root.val - min);
-        max = Math.max(root.val, max);
-        min = Math.min(root.val, min);
-        
-        res = Math.max(res, dfs(root.left, min, max));
-        res = Math.max(res, dfs(root.right, min, max));
-        
-        return res;
-    }
-}

From beddd34f4f148fc4a954884675d04c047c8bb0dc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Nov 2021 21:24:42 -0800
Subject: [PATCH 0629/2175] Create Stock Price Fluctuation.java

---
 Medium/Stock Price Fluctuation.java | 49 +++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 Medium/Stock Price Fluctuation.java

diff --git a/Medium/Stock Price Fluctuation.java b/Medium/Stock Price Fluctuation.java
new file mode 100644
index 00000000..3b374efe
--- /dev/null
+++ b/Medium/Stock Price Fluctuation.java	
@@ -0,0 +1,49 @@
+class StockPrice {
+  Map<Integer, Integer> map;
+  int mostRecentTimeStamp;
+  PriorityQueue<int[]> minHeap;
+  PriorityQueue<int[]> maxHeap;
+  public StockPrice() {
+    map = new HashMap<>();
+    mostRecentTimeStamp = Integer.MIN_VALUE;
+    minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+    maxHeap = new PriorityQueue<>((a, b) -> b[0] - a[0]);
+  }
+
+  public void update(int timestamp, int price) {
+    map.put(timestamp, price);
+    mostRecentTimeStamp = Math.max(mostRecentTimeStamp, timestamp);
+    minHeap.add(new int[]{price, timestamp});
+    maxHeap.add(new int[]{price, timestamp});
+  }
+
+  public int current() {
+    return map.get(mostRecentTimeStamp);
+  }
+
+  public int maximum() {
+    return getUpdatedValueFromHeap(maxHeap);
+  }
+
+  public int minimum() {
+    return getUpdatedValueFromHeap(minHeap);
+  }
+  
+  private int getUpdatedValueFromHeap(PriorityQueue<int[]> heap) {
+    int[] entry = heap.poll();
+    while (entry[0] != map.get(entry[1])) {
+      entry = heap.poll();
+    }
+    heap.add(entry);
+    return entry[0];
+  }
+}
+
+/**
+ * Your StockPrice object will be instantiated and called as such:
+ * StockPrice obj = new StockPrice();
+ * obj.update(timestamp,price);
+ * int param_2 = obj.current();
+ * int param_3 = obj.maximum();
+ * int param_4 = obj.minimum();
+ */

From 617dbc6e7a6a4dcadd7346400a2fb32b25598315 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 10 Nov 2021 15:51:30 -0800
Subject: [PATCH 0630/2175] Create Find the Middle Index in Array.java

---
 Easy/Find the Middle Index in Array.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Find the Middle Index in Array.java

diff --git a/Easy/Find the Middle Index in Array.java b/Easy/Find the Middle Index in Array.java
new file mode 100644
index 00000000..9f95a996
--- /dev/null
+++ b/Easy/Find the Middle Index in Array.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int findMiddleIndex(int[] nums) {
+    int[] leftSum = new int[nums.length];
+    int[] rightSum = new int[nums.length];
+    int currSum = 0;
+    for (int i = 0; i < nums.length; i++) {
+      leftSum[i] = currSum;
+      currSum += nums[i];
+    }
+    currSum = 0;
+    for (int i = nums.length - 1; i >= 0; i--) {
+      rightSum[i] = currSum;
+      currSum += nums[i];
+    }
+    for (int i = 0; i < nums.length; i++) {
+      if (leftSum[i] == rightSum[i]) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}

From 0c299dc4dd78a2696446c5504b0d67317f74be55 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 10 Nov 2021 18:09:27 -0800
Subject: [PATCH 0631/2175] Update Minimum Value to Get Positive Step by Step
 Sum.java

---
 ...inimum Value to Get Positive Step by Step Sum.java | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/Easy/Minimum Value to Get Positive Step by Step Sum.java b/Easy/Minimum Value to Get Positive Step by Step Sum.java
index 4745ae33..0d7401f1 100644
--- a/Easy/Minimum Value to Get Positive Step by Step Sum.java	
+++ b/Easy/Minimum Value to Get Positive Step by Step Sum.java	
@@ -1,14 +1,11 @@
 class Solution {
   public int minStartValue(int[] nums) {
-    int startValue = 1;
-    int currSum = startValue;
+    int minPrefixSum = 0;
+    int currSum = 0;
     for (int num : nums) {
       currSum += num;
-      if (currSum < 1) {
-        startValue += 1 - currSum;
-        currSum += 1 - currSum;
-      }
+      minPrefixSum = Math.min(minPrefixSum, currSum);
     }
-    return startValue;
+    return -1 * minPrefixSum + 1;
   }
 }

From 134f714dcdac6c78a6c9a0cbd186c37eb55c0bac Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 12 Nov 2021 15:30:26 -0800
Subject: [PATCH 0632/2175] Create Evaluate the Bracket Pairs of a String.java

---
 ...valuate the Bracket Pairs of a String.java | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Evaluate the Bracket Pairs of a String.java

diff --git a/Medium/Evaluate the Bracket Pairs of a String.java b/Medium/Evaluate the Bracket Pairs of a String.java
new file mode 100644
index 00000000..3a90861a
--- /dev/null
+++ b/Medium/Evaluate the Bracket Pairs of a String.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public String evaluate(String s, List<List<String>> knowledge) {
+    Map<String, String> map = new HashMap<>();
+    for (List<String> entry : knowledge) {
+      map.put(entry.get(0), entry.get(1));
+    }
+    StringBuilder sb = new StringBuilder();
+    int idx = 0;
+    int n = s.length();
+    while (idx < n) {
+      if (s.charAt(idx) == '(') {
+        idx++;
+        int currIdx = idx;
+        while (idx < n && s.charAt(idx) != ')') {
+          idx++;
+        }
+        sb.append(map.getOrDefault(s.substring(currIdx, idx++), "?"));
+      } else {
+        sb.append(s.charAt(idx++));
+      }
+    }
+    return sb.toString();
+  }
+}

From cad05dab991bc73090b4fd468aa879202fffaf33 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 13 Nov 2021 09:58:25 -0800
Subject: [PATCH 0633/2175] Create Check Whether Two Strings are Almost
 Equivalent.java

---
 ...heck Whether Two Strings are Almost Equivalent.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Check Whether Two Strings are Almost Equivalent.java

diff --git a/Easy/Check Whether Two Strings are Almost Equivalent.java b/Easy/Check Whether Two Strings are Almost Equivalent.java
new file mode 100644
index 00000000..b417eb30
--- /dev/null
+++ b/Easy/Check Whether Two Strings are Almost Equivalent.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public boolean checkAlmostEquivalent(String word1, String word2) {
+    int[] counter = new int[26];
+    for (int i = 0; i < word1.length(); i++) {
+      counter[word1.charAt(i) - 'a']++;
+      counter[word2.charAt(i) - 'a']--;
+    }
+    return IntStream.range(0, 26).allMatch(idx -> Math.abs(counter[idx]) <= 3);
+  }
+}

From e207ab975bb1574441ed1d5f15c5879a025e8fac Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 14 Nov 2021 07:30:23 -0800
Subject: [PATCH 0634/2175] Create Time Needed to Buy Tickets.java

---
 Easy/Time Needed to Buy Tickets.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Time Needed to Buy Tickets.java

diff --git a/Easy/Time Needed to Buy Tickets.java b/Easy/Time Needed to Buy Tickets.java
new file mode 100644
index 00000000..8f7e1a57
--- /dev/null
+++ b/Easy/Time Needed to Buy Tickets.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int timeRequiredToBuy(int[] tickets, int k) {
+    int timeRequired = 0;
+    for(int i = 0;i < tickets.length; i++){
+      if(i <= k){
+          timeRequired += Math.min(tickets[k], tickets[i]);
+      } else {
+          timeRequired += Math.min(tickets[k] - 1, tickets[i]);
+      }
+    }
+    return timeRequired;
+  }
+}

From 83d4fa8b2592b9997dd6491711fbff7751324e2c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 Nov 2021 15:30:39 -0800
Subject: [PATCH 0635/2175] Create Reverse Nodes in Even Length Groups.java

---
 .../Reverse Nodes in Even Length Groups.java  | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 Medium/Reverse Nodes in Even Length Groups.java

diff --git a/Medium/Reverse Nodes in Even Length Groups.java b/Medium/Reverse Nodes in Even Length Groups.java
new file mode 100644
index 00000000..5b723f6a
--- /dev/null
+++ b/Medium/Reverse Nodes in Even Length Groups.java	
@@ -0,0 +1,57 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode reverseEvenLengthGroups(ListNode head) {
+    if (head == null) {
+      return head;
+    }
+    int numOfNodes = 1;
+    ListNode prev = null;
+    ListNode curr = head;
+    int totalNumOfNodes = 0;
+    while (curr != null) {
+      totalNumOfNodes++;
+      curr = curr.next;
+    }
+    curr = head;
+    while (curr != null) {
+      numOfNodes = Math.min(numOfNodes, totalNumOfNodes);
+      totalNumOfNodes -= numOfNodes;
+      if (numOfNodes % 2 == 0) {
+        ListNode[] res = reverseList(curr, numOfNodes);
+        prev.next = res[0];
+        prev = curr;
+        curr = res[1];
+      } else {
+        for (int i = 0; i < numOfNodes && curr != null; i++) {
+          prev = curr;
+          curr = curr.next;
+        }
+      }
+      numOfNodes++;
+    }
+    return head;
+  }
+  
+    private ListNode[] reverseList(ListNode node, int n) {
+      ListNode prev = null;
+      ListNode curr = node;
+      ListNode post = null;
+      while (n-- > 0) {
+        post = curr.next;
+        curr.next = prev;
+        prev = curr;
+        curr = post;
+      }
+      node.next = curr;
+      return new ListNode[]{prev, post};
+  }
+}

From 0cf4bfc5e933f2df7d66b43519c7d87d77486aa7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 16 Nov 2021 06:57:03 -0800
Subject: [PATCH 0636/2175] Create Kth Smallest Number in Multiplication
 Table.java

---
 ...allest Number in Multiplication Table.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Hard/Kth Smallest Number in Multiplication Table.java

diff --git a/Hard/Kth Smallest Number in Multiplication Table.java b/Hard/Kth Smallest Number in Multiplication Table.java
new file mode 100644
index 00000000..84d55bf2
--- /dev/null
+++ b/Hard/Kth Smallest Number in Multiplication Table.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int findKthNumber(int m, int n, int k) {
+    int low = 0;
+    int high = m * n;
+    while (low < high) {
+      int mid = (low + high) / 2;
+      int count = 0;
+      for (int i = 1; i <= m; i++) {
+        count += Math.min(n, mid / i);
+      }
+      if (count >= k) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+    return low;
+  }
+}

From 9064ac3787089012993b8117d0aae7857b95b8a3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 17 Nov 2021 05:45:47 -0800
Subject: [PATCH 0637/2175] Update Unique Paths.java

---
 Medium/Unique Paths.java | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/Medium/Unique Paths.java b/Medium/Unique Paths.java
index 5bea1273..8f1be73d 100644
--- a/Medium/Unique Paths.java	
+++ b/Medium/Unique Paths.java	
@@ -1,21 +1,20 @@
 class Solution {
-  Integer[][] dp;
   public int uniquePaths(int m, int n) {
-    dp = new Integer[m][n];
-    return dfs(m, n, 0, 0);
+    Integer[][] dp = new Integer[m][n];
+    return helper(0, 0, m, n, dp);
   }
   
-  private int dfs(int m, int n, int x, int y) {
-    if (x >= m || y >= n) {
-      return 0;
+  private int helper(int currX, int currY, int m, int n, Integer[][] dp) {
+    if (currX == m - 1 && currY == n - 1) {
+      return 1;
     }
-    if (dp[x][y] != null) {
-      return dp[x][y];
+    if (currX >= m || currY >= n) {
+      return 0;
     }
-    if (x == m - 1 && y == n - 1) {
-      return 1;
+    if (dp[currX][currY] != null) {
+      return dp[currX][currY];
     }
-    dp[x][y] = dfs(m, n, x + 1, y) + dfs(m, n, x, y + 1);
-    return dp[x][y];
+    dp[currX][currY] = helper(currX + 1, currY, m, n, dp) + helper(currX, currY + 1, m, n, dp);
+    return dp[currX][currY];
   }
 }

From 5a23685ddb4b0cdf81b8948f55edc9bfcdcef5cc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 19 Nov 2021 09:07:12 -0800
Subject: [PATCH 0638/2175] Create Design Front Middle Back Queue.java

---
 Medium/Design Front Middle Back Queue.java | 64 ++++++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 Medium/Design Front Middle Back Queue.java

diff --git a/Medium/Design Front Middle Back Queue.java b/Medium/Design Front Middle Back Queue.java
new file mode 100644
index 00000000..cee37d34
--- /dev/null
+++ b/Medium/Design Front Middle Back Queue.java	
@@ -0,0 +1,64 @@
+class FrontMiddleBackQueue {
+
+  Deque<Integer> frontQueue;
+  Deque<Integer> backQueue;
+
+  public FrontMiddleBackQueue() {
+    frontQueue = new ArrayDeque<>();
+    backQueue = new ArrayDeque<>();
+  }
+
+  public void pushFront(int val) {
+    frontQueue.addFirst(val);
+  }
+
+  public void pushMiddle(int val) {
+    while (frontQueue.size() + 1 < backQueue.size()) {
+      frontQueue.addLast(backQueue.removeFirst());
+    }
+    while (frontQueue.size() > backQueue.size()) {
+      backQueue.addFirst(frontQueue.removeLast());
+    }
+    frontQueue.addLast(val);
+  }
+
+  public void pushBack(int val) {
+    backQueue.addLast(val);
+  }
+
+  public int popFront() {
+    return frontQueue.isEmpty()
+        ? (backQueue.isEmpty() ? -1 : backQueue.removeFirst())
+        : frontQueue.removeFirst();
+  }
+
+  public int popMiddle() {
+    if (frontQueue.isEmpty() && backQueue.isEmpty()) {
+      return -1;
+    }
+    while (frontQueue.size() < backQueue.size()) {
+      frontQueue.addLast(backQueue.removeFirst());
+    }
+    while (frontQueue.size() > backQueue.size() + 1) {
+      backQueue.addFirst(frontQueue.removeLast());
+    }
+    return !frontQueue.isEmpty() ? frontQueue.removeLast() : backQueue.removeFirst();
+  }
+
+  public int popBack() {
+    return backQueue.isEmpty()
+        ? (frontQueue.isEmpty() ? -1 : frontQueue.removeLast())
+        : backQueue.removeLast();
+  }
+}
+
+/**
+ * Your FrontMiddleBackQueue object will be instantiated and called as such:
+ * FrontMiddleBackQueue obj = new FrontMiddleBackQueue();
+ * obj.pushFront(val);
+ * obj.pushMiddle(val);
+ * obj.pushBack(val);
+ * int param_4 = obj.popFront();
+ * int param_5 = obj.popMiddle();
+ * int param_6 = obj.popBack();
+ */

From 9d7c3e6619e7cf9e7c30e7250f23db28356f5a22 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Nov 2021 06:39:43 -0800
Subject: [PATCH 0639/2175] Create Two Furthest Houses With Different
 Colors.java

---
 Easy/Two Furthest Houses With Different Colors.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Two Furthest Houses With Different Colors.java

diff --git a/Easy/Two Furthest Houses With Different Colors.java b/Easy/Two Furthest Houses With Different Colors.java
new file mode 100644
index 00000000..af52bca8
--- /dev/null
+++ b/Easy/Two Furthest Houses With Different Colors.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int maxDistance(int[] colors) {
+    int startIdx = 0;
+    int endIdx = colors.length - 1;
+    while (colors[0] == colors[endIdx]) {
+      endIdx--;
+    }
+    while (colors[colors.length - 1] == colors[startIdx]) {
+      startIdx++;
+    }
+    return Math.max(colors.length - 1 - startIdx, endIdx);
+  }
+}

From e1f30a9f31a3fe53652e70474296ab4202fcf885 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Nov 2021 06:30:53 -0800
Subject: [PATCH 0640/2175] Create Watering Plants.java

---
 Medium/Watering Plants.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Watering Plants.java

diff --git a/Medium/Watering Plants.java b/Medium/Watering Plants.java
new file mode 100644
index 00000000..afa36ee2
--- /dev/null
+++ b/Medium/Watering Plants.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int wateringPlants(int[] plants, int capacity) {
+    int idx = 0;
+    int currCapacity = capacity;
+    int totalSteps = 0;
+    while (idx < plants.length) {
+      if (currCapacity < plants[idx]) {
+        currCapacity = capacity;
+        totalSteps += 2 * idx;
+      }
+      currCapacity -= plants[idx++];
+      totalSteps++;
+    }
+    return totalSteps;
+  }
+}

From 582aea891f3f41b959559151fd5cf92df2bb6d7d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Nov 2021 06:38:37 -0800
Subject: [PATCH 0641/2175] Update Delete Node in a BST.java

---
 Medium/Delete Node in a BST.java | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/Medium/Delete Node in a BST.java b/Medium/Delete Node in a BST.java
index 8502798f..4f9cb6eb 100644
--- a/Medium/Delete Node in a BST.java	
+++ b/Medium/Delete Node in a BST.java	
@@ -20,16 +20,13 @@ public TreeNode deleteNode(TreeNode root, int key) {
     }
     if (root.val > key) {
       root.left = deleteNode(root.left, key);
-    }
-    else if (root.val < key) {
+    } else if (root.val < key) {
       root.right = deleteNode(root.right, key);
-    }
-    else {
+    } else {
       if (root.left == null || root.right == null) {
         TreeNode temp = root.left == null ? root.right : root.left;
         return temp;
-      }
-      else {
+      } else {
         TreeNode inorderSuccessor = root.right;
         while (inorderSuccessor.left != null) {
           inorderSuccessor = inorderSuccessor.left;

From 80d54ce4aea7b7e2e7a33ff93f036546269a0945 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Nov 2021 05:56:27 -0800
Subject: [PATCH 0642/2175] Update Interval List Intersections.java

---
 Medium/Interval List Intersections.java | 29 ++++++++++++-------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/Medium/Interval List Intersections.java b/Medium/Interval List Intersections.java
index 0b7c1033..6441b8ec 100644
--- a/Medium/Interval List Intersections.java	
+++ b/Medium/Interval List Intersections.java	
@@ -1,22 +1,21 @@
 class Solution {
-  public int[][] intervalIntersection(int[][] A, int[][] B) {
+  public int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
     List<int[]> list = new ArrayList<>();
-    int startA = 0;
-    int startB = 0;
-    while (startA < A.length && startB < B.length) {
-      int intervalStart = Math.max(A[startA][0], B[startB][0]);
-      int intervalEnd = Math.min(A[startA][1], B[startB][1]);
-      if (intervalStart <= intervalEnd) {
-        list.add(new int[]{intervalStart, intervalEnd});
+    int idxOne = 0;
+    int idxTwo = 0;
+    while (idxOne < firstList.length && idxTwo < secondList.length) {
+      int maxStart = Math.max(firstList[idxOne][0], secondList[idxTwo][0]);
+      int minEnd = Math.min(firstList[idxOne][1], secondList[idxTwo][1]);
+      if (maxStart <= minEnd) {
+        list.add(new int[]{maxStart, minEnd});
       }
-      if (A[startA][1] < B[startB][1]) {
-        startA++;
-      }
-      else {
-        startB++;
+      if (minEnd == firstList[idxOne][1]) {
+        idxOne++;
+      } else {
+        idxTwo++;
       }
     }
-    int[][] ans = new int[list.size()][2];
-    return list.toArray(ans);
+    int[][] result = new int[list.size()][2];
+    return list.toArray(result);
   }
 }

From 665141b21ddba9d615f22f8065740312002ac955 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 25 Nov 2021 16:28:19 -0800
Subject: [PATCH 0643/2175] Update Search Insert Position.java

---
 Easy/Search Insert Position.java | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/Easy/Search Insert Position.java b/Easy/Search Insert Position.java
index b6187b17..3e2f930c 100644
--- a/Easy/Search Insert Position.java	
+++ b/Easy/Search Insert Position.java	
@@ -1,19 +1,17 @@
 class Solution {
   public int searchInsert(int[] nums, int target) {
-    int low = 0;
-    int high = nums.length - 1;
-    while (low <= high) {
-      int mid = (low + high) / 2;
+    int left = 0;
+    int right = nums.length - 1;
+    while (left <= right) {
+      int mid = (left + right) / 2;
       if (nums[mid] == target) {
         return mid;
-      }
-      else if (nums[mid] > target) {
-        high = mid - 1;
-      }
-      else {
-        low = mid + 1;
+      } else if (nums[mid] > target) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
       }
     }
-    return low;
+    return left;
   }
 }

From 9e1aad7bac70d9f7ff89c8a60129190e748e0d26 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Nov 2021 06:13:49 -0800
Subject: [PATCH 0644/2175] Create Count Common Words With One Occurrence.java

---
 Easy/Count Common Words With One Occurrence.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Count Common Words With One Occurrence.java

diff --git a/Easy/Count Common Words With One Occurrence.java b/Easy/Count Common Words With One Occurrence.java
new file mode 100644
index 00000000..514a87bc
--- /dev/null
+++ b/Easy/Count Common Words With One Occurrence.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int countWords(String[] words1, String[] words2) {
+    Map<String, int[]> map = new HashMap<>();
+    buildFrequencyMap(words1, map, 0);
+    buildFrequencyMap(words2, map, 1);
+    return (int) map.entrySet().stream()
+        .filter(entry -> entry.getValue()[0] == 1 && entry.getValue()[1] == 1)
+        .count();
+  }
+
+  private void buildFrequencyMap(String[] words, Map<String, int[]> map, int idx) {
+    for (String word : words) {
+      map.computeIfAbsent(word, k -> new int[2])[idx]++;
+    }
+  }
+}

From b659134cbe0491b7444115938be24acf4277b029 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 29 Nov 2021 07:08:26 -0800
Subject: [PATCH 0645/2175] Create Find Target Indices After Sorting Array.java

---
 ...nd Target Indices After Sorting Array.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Find Target Indices After Sorting Array.java

diff --git a/Easy/Find Target Indices After Sorting Array.java b/Easy/Find Target Indices After Sorting Array.java
new file mode 100644
index 00000000..f0776eba
--- /dev/null
+++ b/Easy/Find Target Indices After Sorting Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public List<Integer> targetIndices(int[] nums, int target) {
+    int count = 0;
+    int lessThanCount = 0;
+    for (int num : nums) {
+      if (num == target) {
+        count++;
+      }
+      if (num < target) {
+        lessThanCount++;
+      }
+    }
+    List<Integer> indices = new ArrayList<>();
+    for (int i = 0; i < count; i++) {
+      indices.add(lessThanCount + i);
+    }
+    return indices;
+  }
+}

From dcc11e62466c49a8c81664b138b0de4494c14e7b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 4 Dec 2021 06:35:26 -0800
Subject: [PATCH 0646/2175] Update Stream of Characters.java

---
 Hard/Stream of Characters.java | 49 ++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 23 deletions(-)

diff --git a/Hard/Stream of Characters.java b/Hard/Stream of Characters.java
index 02fe377a..2f3fbed7 100644
--- a/Hard/Stream of Characters.java	
+++ b/Hard/Stream of Characters.java	
@@ -1,19 +1,23 @@
 class StreamChecker {
-  TrieNode root;
+  
   Deque<Character> stream;
+  TrieNode root;
   public StreamChecker(String[] words) {
     root = new TrieNode('-');
-    stream = new ArrayDeque();
-    for (String word : words) {
-      TrieNode curr = root;
-      for (int i = word.length() - 1; i >= 0; i--) {
-        if (!curr.map.containsKey(word.charAt(i))) {
-          curr.map.put(word.charAt(i), new TrieNode(word.charAt(i)));
-        }
-        curr = curr.map.get(word.charAt(i));
+    stream = new ArrayDeque<>();
+    Arrays.stream(words).forEach(word -> addWord(word));
+  }
+  
+  public void addWord(String word) {
+    TrieNode curr = root;
+    for (int i = word.length() - 1; i >= 0; i--) {
+      char c = word.charAt(i);
+      if (curr.children[c - 'a'] == null) {
+        curr.children[c - 'a'] = new TrieNode(c);
       }
-      curr.isWord = true;
+      curr = curr.children[c - 'a'];
     }
+    curr.isWord = true;
   }
 
   public boolean query(char letter) {
@@ -23,25 +27,24 @@ public boolean query(char letter) {
       if (curr.isWord) {
         return true;
       }
-      if (!curr.map.containsKey(c)) {
+      if (curr.children[c - 'a'] == null) {
         return false;
       }
-      curr = curr.map.get(c);
+      curr = curr.children[c - 'a'];
     }
     return curr.isWord;
   }
-}
-
-
-class TrieNode {
-  char c;
-  Map<Character, TrieNode> map;
-  boolean isWord;
   
-  public TrieNode(char c) {
-    this.c = c;
-    map = new HashMap<>();
-    isWord = false;
+  
+  class TrieNode {
+    char c;
+    TrieNode[] children;
+    boolean isWord;
+    
+    public TrieNode(char c) {
+      this.c = c;
+      children = new TrieNode[26];
+    }
   }
 }
 

From ee8a4c149492a2745d5429f4be88c582209fe50e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 Dec 2021 14:23:47 -0800
Subject: [PATCH 0647/2175] Create Finding 3-Digit Even Numbers.java

---
 Easy/Finding 3-Digit Even Numbers.java | 33 ++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 Easy/Finding 3-Digit Even Numbers.java

diff --git a/Easy/Finding 3-Digit Even Numbers.java b/Easy/Finding 3-Digit Even Numbers.java
new file mode 100644
index 00000000..e8feb4aa
--- /dev/null
+++ b/Easy/Finding 3-Digit Even Numbers.java	
@@ -0,0 +1,33 @@
+class Solution {
+  public int[] findEvenNumbers(int[] digits) {
+    List<Integer> list = new ArrayList<>();
+    int[] counter = new int[10];
+    for (int digit : digits) {
+      counter[digit]++;
+    }
+    for (int digitOne = 1; digitOne <= 9; digitOne++) {
+      if (counter[digitOne] > 0) {
+        counter[digitOne]--;
+        for (int digitTwo = 0; digitTwo <= 9; digitTwo++) {
+          if (counter[digitTwo] > 0) {
+            counter[digitTwo]--;
+            for (int digitThree = 0; digitThree <= 8; digitThree += 2) {
+              if (counter[digitThree] > 0) {
+                list.add(digitOne * 100 + digitTwo * 10 + digitThree);
+              }
+            }
+            counter[digitTwo]++;
+          }
+        }
+        counter[digitOne]++;
+      }
+    }
+    int[] result = new int[list.size()];
+    int idx = 0;
+    for (int num : list) {
+      result[idx++] = num;
+    }
+    Arrays.sort(result);
+    return result;
+  }
+}

From 5632d7dea94df461ebe0fa3eb643529ec880fdae Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Dec 2021 09:38:30 -0800
Subject: [PATCH 0648/2175] Create Minimum Cost to Move Chips to The Same
 Position.java

---
 ...um Cost to Move Chips to The Same Position.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Minimum Cost to Move Chips to The Same Position.java

diff --git a/Easy/Minimum Cost to Move Chips to The Same Position.java b/Easy/Minimum Cost to Move Chips to The Same Position.java
new file mode 100644
index 00000000..7208148a
--- /dev/null
+++ b/Easy/Minimum Cost to Move Chips to The Same Position.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int minCostToMoveChips(int[] position) {
+    int evenCount = 0;
+    int oddCount = 0;
+    for (int p : position) {
+      if (p % 2 == 0) {
+        evenCount++;
+      } else {
+        oddCount++;
+      }
+    }
+    return Math.min(evenCount, oddCount);
+  }
+}

From 73ee8a58f3bdf5caef8d8967d65768180aec7c51 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Dec 2021 09:43:45 -0800
Subject: [PATCH 0649/2175] Create Delete the Middle Node of a Linked List.java

---
 ...lete the Middle Node of a Linked List.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Delete the Middle Node of a Linked List.java

diff --git a/Medium/Delete the Middle Node of a Linked List.java b/Medium/Delete the Middle Node of a Linked List.java
new file mode 100644
index 00000000..1fe07371
--- /dev/null
+++ b/Medium/Delete the Middle Node of a Linked List.java	
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode deleteMiddle(ListNode head) {
+    if (head.next == null) {
+      return null;
+    } 
+    ListNode slow = head;
+    ListNode fast = head.next.next;
+    while (fast != null && fast.next != null) {
+      slow = slow.next;
+      fast = fast.next.next;
+    }
+    slow.next = slow.next.next;
+    return head;
+  }
+}

From b9ae48f66a985fd25318a9caea934511bcb526b8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Dec 2021 07:07:38 -0800
Subject: [PATCH 0650/2175] Update Convert Binary Number in a Linked List to
 Integer.java

---
 ...ry Number in a Linked List to Integer.java | 30 +++++++++----------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/Easy/Convert Binary Number in a Linked List to Integer.java b/Easy/Convert Binary Number in a Linked List to Integer.java
index 22ed597d..88ac4468 100644
--- a/Easy/Convert Binary Number in a Linked List to Integer.java	
+++ b/Easy/Convert Binary Number in a Linked List to Integer.java	
@@ -3,27 +3,25 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
   public int getDecimalValue(ListNode head) {
-    int length = getLength(head);
-    int sum = 0;
-    while (head != null) {
-      sum += ((int) Math.pow(2, length - 1)) * head.val;
-      length--;
-      head = head.next;
+    int nodeLength = -1;
+    ListNode curr = head;
+    while (curr != null) {
+      nodeLength++;
+      curr = curr.next;
     }
-    return sum;
-  }
-  
-  private int getLength(ListNode head) {
-    int count = 0;
-    while (head != null) {
-      count++;
-      head = head.next;
+    int decimalValue = 0;
+    curr = head;
+    while (curr != null) {
+      decimalValue += curr.val * Math.pow(2, nodeLength--);
+      curr = curr.next;
     }
-    return count;
+    return decimalValue;
   }
 }

From 3d94752af01bf762eae65ece11ce30416ac0edbb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Dec 2021 11:31:20 -0800
Subject: [PATCH 0651/2175] Create Step-By-Step Directions From a Binary Tree
 Node to Another.java

---
 ...ns From a Binary Tree Node to Another.java | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 Medium/Step-By-Step Directions From a Binary Tree Node to Another.java

diff --git a/Medium/Step-By-Step Directions From a Binary Tree Node to Another.java b/Medium/Step-By-Step Directions From a Binary Tree Node to Another.java
new file mode 100644
index 00000000..59695899
--- /dev/null
+++ b/Medium/Step-By-Step Directions From a Binary Tree Node to Another.java	
@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public String getDirections(TreeNode root, int startValue, int destValue) {
+    StringBuilder sourcePath = new StringBuilder();
+    StringBuilder destinationPath = new StringBuilder();
+    findPath(root, startValue, sourcePath);
+    findPath(root, destValue, destinationPath);
+    int idx = 0;
+    // Remove common prefix
+    while (idx < Math.min(sourcePath.length(), destinationPath.length()) && 
+           sourcePath.charAt(sourcePath.length() - idx - 1) == destinationPath.charAt(destinationPath.length() - idx - 1)) {
+      idx++;
+    }
+    // Replace remaining sourcePath with 'U' and append remaining destinationPath
+    return "U".repeat(sourcePath.length() - idx) + destinationPath.reverse().toString().substring(idx);
+  }
+  
+  private boolean findPath(TreeNode root, int value, StringBuilder sb) {
+    if (root.val == value) {
+      return true;
+    }
+    if (root.left != null && findPath(root.left, value, sb)) {
+      sb.append("L");
+    }
+    else if (root.right != null && findPath(root.right, value, sb)) {
+      sb.append("R");
+    }
+    return sb.length() > 0;
+  }
+}

From 5f0e3239e3de23f9bab6c770dd92530dbfe44668 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Dec 2021 05:22:53 -0800
Subject: [PATCH 0652/2175] Create Jump Game III.java

---
 Medium/Jump Game III.java | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Jump Game III.java

diff --git a/Medium/Jump Game III.java b/Medium/Jump Game III.java
new file mode 100644
index 00000000..1862ad7c
--- /dev/null
+++ b/Medium/Jump Game III.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public boolean canReach(int[] arr, int start) {
+    Queue<Integer> queue = new LinkedList<>();
+    Set<Integer> visited = new HashSet<>();
+    queue.add(start);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      for (int i = 0; i < size; i++) {
+        int removed = queue.remove();
+        if (arr[removed] == 0) {
+          return true;
+        }
+        if (visited.contains(removed)) {
+          continue;
+        }
+        visited.add(removed);
+        if (removed + arr[removed] < arr.length) {
+          queue.add(removed + arr[removed]);
+        }
+        if (removed - arr[removed] >= 0) {
+          queue.add(removed - arr[removed]);
+        }
+      }
+    }
+    return false;
+  }
+}

From 220ad0ef725b549ec20895abf34bae8421b2af37 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Dec 2021 08:19:35 -0800
Subject: [PATCH 0653/2175] Create Rings and Rods.java

---
 Easy/Rings and Rods.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Rings and Rods.java

diff --git a/Easy/Rings and Rods.java b/Easy/Rings and Rods.java
new file mode 100644
index 00000000..fd98b60a
--- /dev/null
+++ b/Easy/Rings and Rods.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int countPoints(String rings) {
+    Map<Integer, Set<Character>> map = new HashMap<>();
+    for (int i = 0; i < rings.length(); i += 2) {
+      char ring = rings.charAt(i);
+      int rod = Character.getNumericValue(rings.charAt(i + 1));
+      map.computeIfAbsent(rod, k -> new HashSet()).add(ring);
+    }
+    return (int) map.values().stream().filter(v -> v.size() == 3).count();
+  }
+}

From bcb83efe781391a18b82a1579100da7d426b8588 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Dec 2021 12:09:23 -0800
Subject: [PATCH 0654/2175] Rename sum_of_two_integers.java to Sum Of Two
 Integers.java

---
 Easy/{sum_of_two_integers.java => Sum Of Two Integers.java} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename Easy/{sum_of_two_integers.java => Sum Of Two Integers.java} (98%)

diff --git a/Easy/sum_of_two_integers.java b/Easy/Sum Of Two Integers.java
similarity index 98%
rename from Easy/sum_of_two_integers.java
rename to Easy/Sum Of Two Integers.java
index 65f75c56..c1a70d9a 100644
--- a/Easy/sum_of_two_integers.java
+++ b/Easy/Sum Of Two Integers.java	
@@ -5,4 +5,4 @@ public int getSum(int x, int y) {
         else
             return getSum( x ^ y, (x & y) << 1);
     }
-}
\ No newline at end of file
+}

From c290f14c2267038ae2b999aa380cae17de366ec3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Dec 2021 17:48:31 -0800
Subject: [PATCH 0655/2175] Create Range Sum of BST.java

---
 Easy/Range Sum of BST.java | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Easy/Range Sum of BST.java

diff --git a/Easy/Range Sum of BST.java b/Easy/Range Sum of BST.java
new file mode 100644
index 00000000..35b3b6ae
--- /dev/null
+++ b/Easy/Range Sum of BST.java	
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int rangeSumBST(TreeNode root, int low, int high) {
+    int[] rangeSum = {0};
+    helper(root, low, high, rangeSum);
+    return rangeSum[0];
+  }
+  
+  private void helper(TreeNode root, int low, int high, int[] rangeSum) {
+    if (root == null) {
+      return;
+    }
+    if (root.val >= low && root.val <= high) {
+      rangeSum[0] += root.val;
+    }
+    if (root.val >= low) {
+      helper(root.left, low, high, rangeSum);
+    }
+    if (root.val <= high) {
+      helper(root.right, low, high, rangeSum);
+    }
+  }
+}

From 35fe776117d57e24f10c9a89667ab56e8af23cc5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 Dec 2021 06:48:37 -0800
Subject: [PATCH 0656/2175] Create Find First Palindromic String in the
 Array.java

---
 Easy/Find First Palindromic String in the Array.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Find First Palindromic String in the Array.java

diff --git a/Easy/Find First Palindromic String in the Array.java b/Easy/Find First Palindromic String in the Array.java
new file mode 100644
index 00000000..ba990c09
--- /dev/null
+++ b/Easy/Find First Palindromic String in the Array.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public String firstPalindrome(String[] words) {
+    return Arrays.stream(words).filter(Solution::isPalindrome).findFirst().orElse("");
+  }
+  
+  public static boolean isPalindrome(String s) {
+    return new StringBuilder().append(s).reverse().toString().equals(s);
+  }
+}

From 503b8c4d986877a138d8a60149d0c2f044c760ef Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 Dec 2021 06:53:05 -0800
Subject: [PATCH 0657/2175] Create Adding Spaces to a String.java

---
 Medium/Adding Spaces to a String.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Adding Spaces to a String.java

diff --git a/Medium/Adding Spaces to a String.java b/Medium/Adding Spaces to a String.java
new file mode 100644
index 00000000..f1a0dc5f
--- /dev/null
+++ b/Medium/Adding Spaces to a String.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public String addSpaces(String s, int[] spaces) {
+    StringBuilder sb = new StringBuilder();
+    int startIdx = 0;
+    for (int spaceIdx : spaces) {
+      sb.append(s.substring(startIdx, spaceIdx)).append(" ");
+      startIdx = spaceIdx;
+    }
+    sb.append(s.substring(startIdx));
+    return sb.toString();
+  }
+}

From 7f75191ab7dc9e30485b5783d555d6f9bffb8038 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 Dec 2021 07:43:12 -0800
Subject: [PATCH 0658/2175] Update Decode String.java

---
 Medium/Decode String.java | 65 ++++++++++++++++++---------------------
 1 file changed, 30 insertions(+), 35 deletions(-)

diff --git a/Medium/Decode String.java b/Medium/Decode String.java
index 7381fd10..f88449d7 100644
--- a/Medium/Decode String.java	
+++ b/Medium/Decode String.java	
@@ -1,39 +1,34 @@
 class Solution {
-    public static String decodeString(String s) {
-        Stack<Integer> count = new Stack<>();
-        Stack<String> str = new Stack<>();
-        int i = 0;
-        str.push("");
-        while(i < s.length()) {
-            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
-                int start = i;
-                while (s.charAt(i+1) >= '0' && s.charAt(i+1) <= '9') {
-                    i++;
-                }
-                count.push(Integer.parseInt(s.substring(start, i + 1)));
-            }
-            else if (s.charAt(i) == '[') {
-                str.push("");
-            }
-            else if (s.charAt(i) == ']') {
-                String st = str.pop();
-                StringBuilder sb = new StringBuilder();
-                int n = count.pop();
-
-                for (int j = 0; j < n; j++) {
-                    sb.append(st);
-                }
-
-                str.push(str.pop() + sb.toString());
-            }
-            else {
-                str.push(str.pop() + s.charAt(i));
-            }
-
-            i++;
+  public String decodeString(String s) {
+    Stack<Integer> countStack = new Stack<>();
+    Stack<String> wordStack = new Stack<>();
+    StringBuilder sb = new StringBuilder();
+    int idx = 0;
+    while (idx < s.length()) {
+      if (Character.isDigit(s.charAt(idx))) {
+        int count = 0;
+        while (idx < s.length() && Character.isDigit(s.charAt(idx))) {
+          count = count * 10 + Character.getNumericValue(s.charAt(idx++));
         }
-
-        return str.pop();
+        countStack.push(count);
+      } else if (Character.isLetter(s.charAt(idx))) {
+        sb.append(s.charAt(idx++));
+      } else if (s.charAt(idx) == '[') {
+        wordStack.push(sb.toString());
+        sb.setLength(0);
+        idx++;
+      } else {
+        StringBuilder temp = new StringBuilder(wordStack.pop());
+        String currentString = sb.toString();
+        sb.setLength(0);
+        int count = countStack.pop();
+        while (count-- > 0) {
+          temp.append(currentString);
+        }
+        sb.append(temp);
+        idx++;
+      }
     }
+    return sb.toString();
+  }
 }
-

From 48fe7cc83d55e1256d5375f0ff29e9e398410946 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 Dec 2021 16:32:35 -0800
Subject: [PATCH 0659/2175] Create Number of Smooth Descent Periods of a
 Stock.java

---
 ...ber of Smooth Descent Periods of a Stock.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Number of Smooth Descent Periods of a Stock.java

diff --git a/Medium/Number of Smooth Descent Periods of a Stock.java b/Medium/Number of Smooth Descent Periods of a Stock.java
new file mode 100644
index 00000000..34f34227
--- /dev/null
+++ b/Medium/Number of Smooth Descent Periods of a Stock.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public long getDescentPeriods(int[] prices) {
+    long smoothDescentPeriods = 0;
+    int idx = 0;
+    while (idx < prices.length) {
+      long currentDescentPeriod = 1;
+      idx++;
+      while (idx < prices.length && prices[idx - 1] - prices[idx] == 1) {
+        currentDescentPeriod++;
+        idx++;
+      }
+      smoothDescentPeriods += currentDescentPeriod * (currentDescentPeriod + 1) / 2;
+    }
+    return smoothDescentPeriods;
+  }
+}

From 4b0f3def90a5ff95bde1edda45f39e111301c4c7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 20 Dec 2021 08:17:03 -0800
Subject: [PATCH 0660/2175] Update Minimum Absolute Difference.java

---
 Easy/Minimum Absolute Difference.java | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/Easy/Minimum Absolute Difference.java b/Easy/Minimum Absolute Difference.java
index c7204166..793dd171 100644
--- a/Easy/Minimum Absolute Difference.java	
+++ b/Easy/Minimum Absolute Difference.java	
@@ -1,19 +1,16 @@
 class Solution {
   public List<List<Integer>> minimumAbsDifference(int[] arr) {
-    List<List<Integer>> list = new ArrayList<>();
     int minDiff = Integer.MAX_VALUE;
     Arrays.sort(arr);
     for (int i = 0; i < arr.length - 1; i++) {
-      int diff = arr[i + 1] - arr[i];
-      if (diff < minDiff) {
-        list.clear();
-        list.add(Arrays.asList(arr[i], arr[i + 1]));
-        minDiff = diff;
-      }
-      else if (diff == minDiff) {
-        list.add(Arrays.asList(arr[i], arr[i + 1]));
+      minDiff = Math.min(minDiff, arr[i + 1] - arr[i]);
+    }
+    List<List<Integer>> result = new ArrayList<>();
+    for (int i = 0; i < arr.length - 1; i++) {
+      if (arr[i + 1] - arr[i] == minDiff) {
+        result.add(Arrays.asList(arr[i], arr[i + 1]));        
       }
     }
-    return list;
+    return result;
   }
 }

From f7e70d06329435012b541be8d7365b6a468fc536 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 20 Dec 2021 16:28:14 -0800
Subject: [PATCH 0661/2175] Update Power of Two.java

---
 Easy/Power of Two.java | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/Easy/Power of Two.java b/Easy/Power of Two.java
index c4ddd0f3..caf0d77a 100644
--- a/Easy/Power of Two.java	
+++ b/Easy/Power of Two.java	
@@ -1,21 +1,19 @@
 class Solution {
   public boolean isPowerOfTwo(int n) {
-    if (n % 2 != 0 && n != 1) {
+    if (n > 1 && n % 2 != 0) {
       return false;
     }
     int start = 0;
     int end = n / 2;
     while (start <= end) {
       int mid = (start + end) / 2;
-      int pow = (int) (Math.pow(2, mid));
-      if (n == pow) {
+      int pow = (int) Math.pow(2, mid);
+      if (pow == n) {
         return true;
-      }
-      else if (n > pow) {
-        start = mid + 1;
-      }
-      else {
+      } else if (pow > n) {
         end = mid - 1;
+      } else {
+        start = mid + 1;
       }
     }
     return false;

From 8df2835f0dbc7b63cce687f4d71ebd17bb112f39 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 21 Dec 2021 16:43:44 -0800
Subject: [PATCH 0662/2175] Update Reorder List.java

---
 Medium/Reorder List.java | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/Medium/Reorder List.java b/Medium/Reorder List.java
index beb3390b..f67b973c 100644
--- a/Medium/Reorder List.java	
+++ b/Medium/Reorder List.java	
@@ -10,34 +10,35 @@
  */
 class Solution {
   public void reorderList(ListNode head) {
-    if (head == null || head.next == null) {
+    if (head.next == null) {
       return;
     }
-    ListNode fast = head;
+    // Find mid point
     ListNode slow = head;
+    ListNode fast = head;
     while (fast != null && fast.next != null) {
       fast = fast.next.next;
       slow = slow.next;
     }
+    // Reverse the second half & break the two halves
     ListNode secondHalf = reverse(slow.next);
     slow.next = null;
     ListNode firstHalf = head;
-    ListNode firstNext = null;
-    ListNode secondNext = null;
+    // Merge first half and second half
     while (firstHalf != null && secondHalf != null) {
-      firstNext = firstHalf.next;
-      secondNext = secondHalf.next;
+      ListNode firstHalfNext = firstHalf.next;
+      ListNode secondHalfNext = secondHalf.next;
       firstHalf.next = secondHalf;
-      secondHalf.next = firstNext;
-      firstHalf = firstNext;
-      secondHalf = secondNext;
+      secondHalf.next = firstHalfNext;
+      firstHalf = firstHalfNext;
+      secondHalf = secondHalfNext;
     }
   }
   
-  private ListNode reverse(ListNode node) {
-    ListNode curr = node;
-    ListNode prev = null;
+  private ListNode reverse(ListNode head) {
+    ListNode curr = head;
     ListNode next = null;
+    ListNode prev = null;
     while (curr != null) {
       next = curr.next;
       curr.next = prev;

From 7b863f4af4a3e36416c15de0b7a0025b47c94a8f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 24 Dec 2021 07:18:44 -0800
Subject: [PATCH 0663/2175] Update Merge Intervals.java

---
 Medium/Merge Intervals.java | 52 +++++++++++--------------------------
 1 file changed, 15 insertions(+), 37 deletions(-)

diff --git a/Medium/Merge Intervals.java b/Medium/Merge Intervals.java
index c770e419..c4b49872 100644
--- a/Medium/Merge Intervals.java	
+++ b/Medium/Merge Intervals.java	
@@ -1,44 +1,22 @@
 class Solution {
   public int[][] merge(int[][] intervals) {
-    Arrays.sort(intervals, new Comparator<int[]>(){
-      public int compare(int[] o1, int[] o2) {
-        int c = o1[0] - o2[0];
-        if (c != 0) {
-          return c;
-        }
-        return o1[1] - o2[1];
-      }
-    });
-    List<int[]> intervalList = new ArrayList<>();
-    int end = 0;
-    int n = intervals.length;
-    int currStart = -1;
-    int currEnd = -1;
-    while (end < n) {
-      if (currStart == -1 && currEnd == -1) {
-        currStart = intervals[end][0];
-        currEnd = intervals[end][1];
-        end++;
-      }
-      if (end < n) {
-        if (currEnd >= intervals[end][0]) {
-          currEnd = Math.max(intervals[end][1], currEnd);
-          end++;
-        }
-        else {
-          intervalList.add(new int[]{currStart, currEnd});
-          currStart = -1;
-          currEnd = -1;
-        }
-      }
-      if (end == n && currStart != -1 && currEnd != -1) {
-        intervalList.add(new int[]{currStart, currEnd});
+    Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1]));
+    List<int[]> mergedIntervals = new ArrayList<>();
+    int idx = 0;
+    while (idx < intervals.length) {
+      int currentStart = intervals[idx][0];
+      int currentEnd = intervals[idx][1];
+      idx++;
+      while (idx < intervals.length && intervals[idx][0] <= currentEnd) {
+        currentEnd = Math.max(intervals[idx][1], currentEnd);
+        idx++;
       }
+      mergedIntervals.add(new int[]{currentStart, currentEnd});
     }
-    int[][] ans = new int[intervalList.size()][2];
-    for (int i = 0; i < intervalList.size(); i++) {
-      ans[i] = intervalList.get(i);
+    int[][] result = new int[mergedIntervals.size()][2];
+    for (int i = 0; i < mergedIntervals.size(); i++) {
+      result[i] = mergedIntervals.get(i);
     }
-    return ans;
+    return result;
   }
 }

From 8219429189694e756c557afa4a0702be0375b4c0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 25 Dec 2021 23:21:28 -0800
Subject: [PATCH 0664/2175] Update and rename Easy/K Closest Points to
 Origin.java to Medium/K Closest Points to Origin.java

---
 Easy/K Closest Points to Origin.java   | 36 --------------------------
 Medium/K Closest Points to Origin.java | 15 +++++++++++
 2 files changed, 15 insertions(+), 36 deletions(-)
 delete mode 100644 Easy/K Closest Points to Origin.java
 create mode 100644 Medium/K Closest Points to Origin.java

diff --git a/Easy/K Closest Points to Origin.java b/Easy/K Closest Points to Origin.java
deleted file mode 100644
index 950e2783..00000000
--- a/Easy/K Closest Points to Origin.java	
+++ /dev/null
@@ -1,36 +0,0 @@
-class Solution {
-    public int[][] kClosest(int[][] points, int K) {
-        int[][] ans = new int[K][2];
-        PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
-            @Override
-            public int compare(int[] o1, int[] o2) {
-                double dist1 = getDistance(o1);
-                double dist2 = getDistance(o2);
-
-                if (dist1 > dist2) {
-                    return 1;
-                }
-                else if (dist1 < dist2) {
-                    return -1;
-                }
-                else {
-                    return 0;
-                }
-            }
-        });
-
-        for (int[] point : points) {
-            pq.add(point);
-        }
-
-        for (int i=0; i<K; i++) {
-            ans[i] = pq.poll();
-        }
-
-        return ans;
-    }
-
-    private double getDistance(int[] point) {
-        return Math.sqrt(Math.pow(point[0], 2) + Math.pow(point[1], 2));
-    }
-}
diff --git a/Medium/K Closest Points to Origin.java b/Medium/K Closest Points to Origin.java
new file mode 100644
index 00000000..20275fe3
--- /dev/null
+++ b/Medium/K Closest Points to Origin.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int[][] kClosest(int[][] points, int k) {
+    PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> {
+      double diff =  Math.sqrt(o1[0] * o1[0] + o1[1] * o1[1]) - Math.sqrt(
+          o2[0] * o2[0] + o2[1] * o2[1]);
+      return diff < 0 ? -1 : (diff > 0 ? 1 : 0);
+    });
+    Collections.addAll(pq, points);
+    int[][] result = new int[k][2];
+    for (int i = 0; i < k; i++) {
+      result[i] = pq.poll();
+    }
+    return result;
+  }
+}

From 98def039eda25df01e86912a53be85c37f26b4be Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Dec 2021 07:20:39 -0800
Subject: [PATCH 0665/2175] Create Maximum Number of Words Found in
 Sentences.java

---
 Easy/Maximum Number of Words Found in Sentences.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Easy/Maximum Number of Words Found in Sentences.java

diff --git a/Easy/Maximum Number of Words Found in Sentences.java b/Easy/Maximum Number of Words Found in Sentences.java
new file mode 100644
index 00000000..78b2af40
--- /dev/null
+++ b/Easy/Maximum Number of Words Found in Sentences.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public int mostWordsFound(String[] sentences) {
+    return Arrays.stream(sentences).map(sentence -> sentence.split("\\s").length)
+        .max(Integer::compare).orElse(0);
+  }
+}

From 44df3cbb01ebfc2ed14a0d31e35214617c7af333 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Dec 2021 08:00:34 -0800
Subject: [PATCH 0666/2175] Create A Number After a Double Reversal.java

---
 Easy/A Number After a Double Reversal.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/A Number After a Double Reversal.java

diff --git a/Easy/A Number After a Double Reversal.java b/Easy/A Number After a Double Reversal.java
new file mode 100644
index 00000000..0175e45f
--- /dev/null
+++ b/Easy/A Number After a Double Reversal.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public boolean isSameAfterReversals(int num) {
+    return parseToInteger(reverseNum(parseToInteger(reverseNum(num)))) == num;
+  }
+  
+  private String reverseNum(int num) {
+    return new StringBuilder().append(num).reverse().toString();
+  }
+  
+  private Integer parseToInteger(String s) {
+    return Integer.parseInt(s);
+  }
+}

From 569f60d4880ed808bfcd593bc24415538b28ba1c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Dec 2021 21:40:08 -0800
Subject: [PATCH 0667/2175] Create Find All Possible Recipes from Given
 Supplies.java

---
 ... Possible Recipes from Given Supplies.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Medium/Find All Possible Recipes from Given Supplies.java

diff --git a/Medium/Find All Possible Recipes from Given Supplies.java b/Medium/Find All Possible Recipes from Given Supplies.java
new file mode 100644
index 00000000..bf0e2976
--- /dev/null
+++ b/Medium/Find All Possible Recipes from Given Supplies.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public List<String> findAllRecipes(String[] recipes, List<List<String>> ingredients,
+      String[] supplies) {
+    Map<String, Set<String>> ingredientToRecipeMap = new HashMap<>();
+    Map<String, Integer> recipeToIngredientCount = new HashMap<>();
+    for (int i = 0; i < recipes.length; i++) {
+      String recipe = recipes[i];
+      List<String> ingredientsForRecipe = ingredients.get(i);
+      recipeToIngredientCount.put(recipe, ingredientsForRecipe.size());
+      for (String ingredient : ingredientsForRecipe) {
+        ingredientToRecipeMap.computeIfAbsent(ingredient, k -> new HashSet<>()).add(recipe);
+      }
+    }
+    Queue<String> queue = new LinkedList<>(List.of(supplies));
+    Set<String> result = new HashSet<>();
+    while (!queue.isEmpty()) {
+      String ingredient = queue.remove();
+      for (String dependentRecipe : ingredientToRecipeMap.getOrDefault(ingredient,
+          new HashSet<>())) {
+        recipeToIngredientCount.put(dependentRecipe,
+            recipeToIngredientCount.get(dependentRecipe) - 1);
+        if (recipeToIngredientCount.get(dependentRecipe) == 0) {
+          result.add(dependentRecipe);
+          queue.add(dependentRecipe);
+        }
+      }
+    }
+    return new ArrayList<>(result);
+  }
+}

From d8a6a1f2df62d5b5ad47ec1598fe783d4fd4f12d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 28 Dec 2021 10:03:35 -0800
Subject: [PATCH 0668/2175] Create Execution of All Suffix Instructions Staying
 in a Grid.java

---
 ...Suffix Instructions Staying in a Grid.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Execution of All Suffix Instructions Staying in a Grid.java

diff --git a/Medium/Execution of All Suffix Instructions Staying in a Grid.java b/Medium/Execution of All Suffix Instructions Staying in a Grid.java
new file mode 100644
index 00000000..4d231f93
--- /dev/null
+++ b/Medium/Execution of All Suffix Instructions Staying in a Grid.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int[] executeInstructions(int n, int[] startPos, String s) {
+    int[] result = new int[s.length()];
+    Map<Character, int[]> directionToMovementMap = Map.of(
+        'R', new int[]{0, 1},
+        'L', new int[]{0, -1},
+        'U', new int[]{-1, 0},
+        'D', new int[]{1, 0}
+    );
+    for (int i = 0; i < s.length(); i++) {
+      int startX = startPos[0];
+      int startY = startPos[1];
+      int j = i;
+      for (; j < s.length(); j++) {
+        startX += directionToMovementMap.get(s.charAt(j))[0];
+        startY += directionToMovementMap.get(s.charAt(j))[1];
+        if (startX < 0 || startY < 0 || startX >= n || startY >= n) {
+          break;
+        }
+      }
+      result[i] = j - i;
+    }
+    return result;
+  }
+}

From f92f440eaeff9e9a524b8bd2578e7265471a2b0e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 2 Jan 2022 15:04:29 -0800
Subject: [PATCH 0669/2175] Create Check if All A's Appears Before All B's.java

---
 ...Check if All A's Appears Before All B's.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Check if All A's Appears Before All B's.java

diff --git a/Easy/Check if All A's Appears Before All B's.java b/Easy/Check if All A's Appears Before All B's.java
new file mode 100644
index 00000000..aab35c42
--- /dev/null
+++ b/Easy/Check if All A's Appears Before All B's.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public boolean checkString(String s) {
+    boolean aFound = false;
+    boolean bFound = false;
+    for (int i = 0; i < s.length(); i++) {
+      if (s.charAt(i) == 'a') {
+        if (bFound) {
+          return false;
+        }
+        aFound = true;
+      } else {
+        bFound = true;
+      }
+    }
+    return true;
+  }
+}

From 6a6bfb02fa0b8d8b50382287b686593a847f260b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 2 Jan 2022 17:32:57 -0800
Subject: [PATCH 0670/2175] Delete Find the Town Judge.java

---
 Medium/Find the Town Judge.java | 15 ---------------
 1 file changed, 15 deletions(-)
 delete mode 100644 Medium/Find the Town Judge.java

diff --git a/Medium/Find the Town Judge.java b/Medium/Find the Town Judge.java
deleted file mode 100644
index e8597e29..00000000
--- a/Medium/Find the Town Judge.java	
+++ /dev/null
@@ -1,15 +0,0 @@
-class Solution {
-  public int findJudge(int N, int[][] trust) {
-    int[] trustScore = new int[N + 1];
-    for (int[] trst : trust) {
-      trustScore[trst[0]]--;
-      trustScore[trst[1]]++;
-    }
-    for (int i = 1; i <= N; i++) {
-      if (trustScore[i] == (N - 1)) {
-        return i;
-      }
-    }
-    return -1;
-  }
-}

From c45c003f78d2a78a823fa796d05bc5f870698889 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 2 Jan 2022 17:33:39 -0800
Subject: [PATCH 0671/2175] Update Find the Town Judge.java

---
 Easy/Find the Town Judge.java | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/Easy/Find the Town Judge.java b/Easy/Find the Town Judge.java
index 60c4a84f..8605e848 100644
--- a/Easy/Find the Town Judge.java	
+++ b/Easy/Find the Town Judge.java	
@@ -1,18 +1,15 @@
 class Solution {
-    public int findJudge(int N, int[][] trust) {
-        int[] count = new int[N + 1];
-        
-        for (int[] item : trust) {
-            count[item[0]]--;
-            count[item[1]]++;
-        }
-        
-        for (int i = 1; i <= N; i++) {
-            if (count[i] == N - 1) {
-                return i;
-            }
-        }
-        
-        return -1;
+  public int findJudge(int n, int[][] trust) {
+    int[] trustScore = new int[n + 1];
+    for (int[] trustPair : trust) {
+      trustScore[trustPair[1]]++;
+      trustScore[trustPair[0]]--;
     }
+    for (int i = 1; i <= n; i++) {
+      if (trustScore[i] == n - 1) {
+        return i;
+      }
+    }
+    return -1;
+  }
 }

From e5bd56e98bb49209b7501f13f5762074dbbb112a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 3 Jan 2022 08:00:19 -0800
Subject: [PATCH 0672/2175] Create Number of Laser Beams in a Bank.java

---
 Medium/Number of Laser Beams in a Bank.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Number of Laser Beams in a Bank.java

diff --git a/Medium/Number of Laser Beams in a Bank.java b/Medium/Number of Laser Beams in a Bank.java
new file mode 100644
index 00000000..9a03ad92
--- /dev/null
+++ b/Medium/Number of Laser Beams in a Bank.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int numberOfBeams(String[] bank) {
+    int prevLaserCount = 0;
+    int totalNumberOfBeams = 0;
+    for (String beam : bank) {
+      if (beam.indexOf('1') != -1) {
+        int currentBeamCount = (int) beam.chars().mapToObj(c -> (char) c).filter(c -> c == '1')
+            .count();
+        totalNumberOfBeams += prevLaserCount * currentBeamCount;
+        prevLaserCount = currentBeamCount;
+      }
+    }
+    return totalNumberOfBeams;
+  }
+}

From 66bdce518c7055c02ad75e0be01330ca0d17e22c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 5 Jan 2022 06:06:35 -0800
Subject: [PATCH 0673/2175] Create Sum of Beauty of All Substrings.java

---
 Medium/Sum of Beauty of All Substrings.java | 26 +++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Sum of Beauty of All Substrings.java

diff --git a/Medium/Sum of Beauty of All Substrings.java b/Medium/Sum of Beauty of All Substrings.java
new file mode 100644
index 00000000..17d57d14
--- /dev/null
+++ b/Medium/Sum of Beauty of All Substrings.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public int beautySum(String s) {
+    int sum = 0;
+    for (int i = 0; i < s.length(); i++) {
+      int[] charFrequency = new int[26];
+      for (int j = i; j < s.length(); j++) {
+        charFrequency[s.charAt(j) - 'a']++;
+        sum += getBeauty(charFrequency);
+      }
+    }
+    return sum;
+  }
+
+  private int getBeauty(int[] charFrequency) {
+    int min = Integer.MAX_VALUE ;
+    int max = Integer.MIN_VALUE;
+    for (int i = 0; i < 26; i++) {
+      if (charFrequency[i] == 0) {
+        continue;
+      }
+      min = Math.min(min, charFrequency[i]);
+      max = Math.max(max, charFrequency[i]);
+    }
+    return max - min;
+  }
+}

From 9526389329da0d3289327a14dc2d736c999bff4f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 5 Jan 2022 07:13:08 -0800
Subject: [PATCH 0674/2175] Create Most Profit Assigning Work.java

---
 Medium/Most Profit Assigning Work.java | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Most Profit Assigning Work.java

diff --git a/Medium/Most Profit Assigning Work.java b/Medium/Most Profit Assigning Work.java
new file mode 100644
index 00000000..792530db
--- /dev/null
+++ b/Medium/Most Profit Assigning Work.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public int maxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
+    List<Task> tasks = new ArrayList<>();
+    for (int i = 0; i < difficulty.length; i++) {
+      tasks.add(new Task(profit[i], difficulty[i]));
+    }
+    tasks.sort(Comparator.comparingInt(o -> o.difficulty));
+    Arrays.sort(worker);
+    int idx = 0;
+    int maxProfit = 0;
+    int workerProfit = 0;
+    for (int ability : worker) {
+      while (idx < profit.length && ability >= tasks.get(idx).difficulty) {
+        workerProfit = Math.max(workerProfit, tasks.get(idx++).profit);
+      }
+      maxProfit += workerProfit;
+    }
+    return maxProfit;
+  }
+
+
+  class Task {
+    int profit;
+    int difficulty;
+
+    public Task(int profit, int difficulty) {
+      this.profit = profit;
+      this.difficulty = difficulty;
+    }
+  }
+}

From 560963671bdf1049533a2e64c40d14ed51f8e446 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 5 Jan 2022 17:14:33 -0800
Subject: [PATCH 0675/2175] Update Car Pooling.java

---
 Medium/Car Pooling.java | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/Medium/Car Pooling.java b/Medium/Car Pooling.java
index ab96c443..1199d3b5 100644
--- a/Medium/Car Pooling.java	
+++ b/Medium/Car Pooling.java	
@@ -1,20 +1,17 @@
 class Solution {
   public boolean carPooling(int[][] trips, int capacity) {
-    Arrays.sort(trips, Comparator.comparingInt(o -> o[1]));
-    int start = 0;
+    Arrays.sort(trips, Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[2]));
+    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(o -> o[2]));
     int idx = 0;
-    int n = trips.length;
-    int currCapacity = 0;
-    PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
-    while (idx < n) {
-      while (!pq.isEmpty() && pq.peek()[2] <= trips[idx][1]) {
-        currCapacity -= pq.poll()[0];
+    while (idx < trips.length) {
+      while (!priorityQueue.isEmpty() && priorityQueue.peek()[2] <= trips[idx][1]) {
+        capacity += priorityQueue.poll()[0];
       }
-      if (currCapacity + trips[idx][0] > capacity) {
+      if (capacity < trips[idx][0]) {
         return false;
       }
-      currCapacity += trips[idx][0];
-      pq.add(trips[idx++]);
+      priorityQueue.add(trips[idx]);
+      capacity -= trips[idx++][0];
     }
     return true;
   }

From 1c93e37f073a249e3e0f0600288893223fedde90 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 7 Jan 2022 08:31:01 -0800
Subject: [PATCH 0676/2175] Update RLE Iterator.java

---
 Medium/RLE Iterator.java | 55 ++++++++++++++++------------------------
 1 file changed, 22 insertions(+), 33 deletions(-)

diff --git a/Medium/RLE Iterator.java b/Medium/RLE Iterator.java
index 2c1f7683..7baf4e97 100644
--- a/Medium/RLE Iterator.java	
+++ b/Medium/RLE Iterator.java	
@@ -1,42 +1,31 @@
 class RLEIterator {
-    int[] arr;
-    int idx;
-    int len;
-    public RLEIterator(int[] A) {
-        arr = A;
-        idx = 0;
-        len = A.length;
-    }
-    
-    public int next(int n) {
-        while (idx < len - 1 && (arr[idx] - n) < 0) {
-            n -= arr[idx] > 0 ? arr[idx] : 0;
-            updateIdx();
-            
-            if (idx >= len - 1) {
-                return -1;
-            }
-        }
-        
-        if (idx < len - 1 && arr[idx] > 0) {
-            if (arr[idx] - n >= 0) {
-                int temp = arr[idx+1];
-                arr[idx] -= n;
-                
-                return temp;
-            }
-        }
-        
+  
+  int[] encoding;
+  int currCounterIdx;
+
+  public RLEIterator(int[] encoding) {
+    this.encoding = encoding;
+    this.currCounterIdx = 0;
+  }
+
+  public int next(int n) {
+    while (n > 0) {
+      while (this.encoding[this.currCounterIdx] == 0 && this.currCounterIdx + 2 < this.encoding.length) {
+        this.currCounterIdx += 2;
+      }
+      if (this.encoding[this.currCounterIdx] == 0) {
         return -1;
+      }
+      int diff = Math.min(this.encoding[this.currCounterIdx], n);
+      this.encoding[this.currCounterIdx] -= diff;
+      n -= diff;
     }
-    
-    private void updateIdx() {
-       idx += 2;
-    }
+    return this.encoding[this.currCounterIdx + 1];
+  }
 }
 
 /**
  * Your RLEIterator object will be instantiated and called as such:
- * RLEIterator obj = new RLEIterator(A);
+ * RLEIterator obj = new RLEIterator(encoding);
  * int param_1 = obj.next(n);
  */

From 8bcd18ee97cc6a1a654a02f210cb35ebe94964fa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 8 Jan 2022 17:40:14 -0800
Subject: [PATCH 0677/2175] Create Capitalize the Title.java

---
 Easy/Capitalize the Title.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Capitalize the Title.java

diff --git a/Easy/Capitalize the Title.java b/Easy/Capitalize the Title.java
new file mode 100644
index 00000000..2481e553
--- /dev/null
+++ b/Easy/Capitalize the Title.java	
@@ -0,0 +1,8 @@
+class Solution {
+  public String capitalizeTitle(String title) {
+    return Arrays.stream(title.split("\\s+"))
+        .map(e -> e.length() <= 2 ? e.toLowerCase() :
+            e.substring(0, 1).toUpperCase() + e.substring(1).toLowerCase())
+        .collect(Collectors.joining(" "));
+  }
+}

From ba5943cf93333c1327615b1ff7d33b114cb19e10 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Jan 2022 06:55:58 -0800
Subject: [PATCH 0678/2175] Create Check if Every Row and Column Contains All
 Numbers.java

---
 ... Every Row and Column Contains All Numbers.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Check if Every Row and Column Contains All Numbers.java

diff --git a/Easy/Check if Every Row and Column Contains All Numbers.java b/Easy/Check if Every Row and Column Contains All Numbers.java
new file mode 100644
index 00000000..f64e1cfc
--- /dev/null
+++ b/Easy/Check if Every Row and Column Contains All Numbers.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public boolean checkValid(int[][] matrix) {
+    Map<Integer, Set<Integer>> rowMap = new HashMap<>();
+    Map<Integer, Set<Integer>> colMap = new HashMap<>();
+    for (int i = 0; i < matrix.length; i++) {
+      for (int j = 0; j < matrix[0].length; j++) {
+        rowMap.computeIfAbsent(i, k -> new HashSet<>()).add(matrix[i][j]);
+        colMap.computeIfAbsent(j, k -> new HashSet<>()).add(matrix[i][j]);
+      }
+    }
+    return rowMap.values().stream().allMatch(e -> e.size() == matrix.length) && 
+        colMap.values().stream().allMatch(e -> e.size() == matrix.length);
+  }
+}

From 0af0cc05e1135da97de5ecc27c96a8510eb399a5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Jan 2022 07:35:53 -0800
Subject: [PATCH 0679/2175] Create Maximum Twin Sum of a Linked List.java

---
 Medium/Maximum Twin Sum of a Linked List.java | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Medium/Maximum Twin Sum of a Linked List.java

diff --git a/Medium/Maximum Twin Sum of a Linked List.java b/Medium/Maximum Twin Sum of a Linked List.java
new file mode 100644
index 00000000..5f6b44bd
--- /dev/null
+++ b/Medium/Maximum Twin Sum of a Linked List.java	
@@ -0,0 +1,41 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public int pairSum(ListNode head) {
+    ListNode slow = head;
+    ListNode fast = head.next;
+    while (fast != null && fast.next != null) {
+      slow = slow.next;
+      fast = fast.next.next;
+    }
+    fast = reverse(slow.next);
+    slow.next = null;
+    slow = head;
+    int maxSum = 0;
+    for (; slow != null && fast != null; slow = slow.next, fast = fast.next) {
+      maxSum = Math.max(maxSum, slow.val + fast.val);
+    }
+    return maxSum;
+  }
+  
+  private ListNode reverse(ListNode node) {
+    ListNode curr = node;
+    ListNode prev = null;
+    ListNode next = null;
+    while (curr != null) {
+      next = curr.next;
+      curr.next = prev;
+      prev = curr;
+      curr = next;
+    }
+    return prev;
+  }
+}

From b7c0c032e02bcebe75b0631682af9e578c41ff47 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Jan 2022 08:37:49 -0800
Subject: [PATCH 0680/2175] Create Design Movie Rental System.java

---
 Hard/Design Movie Rental System.java | 102 +++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 Hard/Design Movie Rental System.java

diff --git a/Hard/Design Movie Rental System.java b/Hard/Design Movie Rental System.java
new file mode 100644
index 00000000..0aaeb6c8
--- /dev/null
+++ b/Hard/Design Movie Rental System.java	
@@ -0,0 +1,102 @@
+class MovieRentingSystem {
+
+  Comparator<MovieEntry> comparator =
+      (o1, o2) -> {
+        if (o1.price != o2.price) {
+          return o1.price - o2.price;
+        }
+        if (o1.shopId != o2.shopId) {
+          return o1.shopId - o2.shopId;
+        }
+        return o1.movieId - o2.movieId;
+      };
+  Map<Integer, Set<MovieEntry>> movieToUnrentedShopMapping;
+  Map<ShopMoviePair, Integer> shopMoviePairToPriceMapping;
+  TreeSet<MovieEntry> rentedMovies;
+
+  public MovieRentingSystem(int n, int[][] entries) {
+    movieToUnrentedShopMapping = new HashMap<>();
+    shopMoviePairToPriceMapping = new HashMap<>();
+    rentedMovies = new TreeSet<>(comparator);
+    for (int[] entry : entries) {
+      movieToUnrentedShopMapping
+          .computeIfAbsent(entry[1], k -> new TreeSet<>(comparator))
+          .add(new MovieEntry(entry[1], entry[2], entry[0]));
+      shopMoviePairToPriceMapping.put(new ShopMoviePair(entry[0], entry[1]), entry[2]);
+    }
+  }
+
+  public List<Integer> search(int movie) {
+    return movieToUnrentedShopMapping.getOrDefault(movie, Collections.emptySet()).stream()
+        .limit(5)
+        .map(e -> e.shopId)
+        .collect(Collectors.toList());
+  }
+
+  public void rent(int shop, int movie) {
+    int price = shopMoviePairToPriceMapping.get(new ShopMoviePair(shop, movie));
+    movieToUnrentedShopMapping.get(movie).remove(new MovieEntry(movie, price, shop));
+    rentedMovies.add(new MovieEntry(movie, price, shop));
+  }
+
+  public void drop(int shop, int movie) {
+    int price = shopMoviePairToPriceMapping.get(new ShopMoviePair(shop, movie));
+    movieToUnrentedShopMapping.get(movie).add(new MovieEntry(movie, price, shop));
+    rentedMovies.remove(new MovieEntry(movie, price, shop));
+  }
+
+  public List<List<Integer>> report() {
+    return rentedMovies.stream()
+        .limit(5)
+        .map(e -> List.of(e.shopId, e.movieId))
+        .collect(Collectors.toList());
+  }
+
+  class ShopMoviePair {
+    int shopId;
+    int movieId;
+
+    public ShopMoviePair(int shopId, int movieId) {
+      this.shopId = shopId;
+      this.movieId = movieId;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      ShopMoviePair that = (ShopMoviePair) o;
+      return shopId == that.shopId && movieId == that.movieId;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(shopId, movieId);
+    }
+  }
+
+  class MovieEntry {
+    int movieId;
+    int price;
+    int shopId;
+
+    public MovieEntry(int movieId, int price, int shopId) {
+      this.movieId = movieId;
+      this.price = price;
+      this.shopId = shopId;
+    }
+  }
+}
+
+/**
+ * Your MovieRentingSystem object will be instantiated and called as such:
+ * MovieRentingSystem obj = new MovieRentingSystem(n, entries);
+ * List<Integer> param_1 = obj.search(movie);
+ * obj.rent(shop,movie);
+ * obj.drop(shop,movie);
+ * List<List<Integer>> param_4 = obj.report();
+ */

From dd9e4d8f5707f4cd43dfc826737cb5fd06a1b75b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Jan 2022 14:47:45 -0800
Subject: [PATCH 0681/2175] Update Binary Tree Pruning.java

---
 Medium/Binary Tree Pruning.java | 46 +++++++++++++++++----------------
 1 file changed, 24 insertions(+), 22 deletions(-)

diff --git a/Medium/Binary Tree Pruning.java b/Medium/Binary Tree Pruning.java
index 8bcf8f80..a03af5a7 100644
--- a/Medium/Binary Tree Pruning.java	
+++ b/Medium/Binary Tree Pruning.java	
@@ -4,32 +4,34 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode pruneTree(TreeNode root) {
-        return checker(root);   
+  public TreeNode pruneTree(TreeNode root) {
+    boolean isRootOne = helper(root);
+    return isRootOne ? root : null;
+  }
+  
+  private boolean helper(TreeNode root) {
+    if (root == null) {
+      return false;
     }
-    
-// A checker method which checks every node and makes it null if it doesn't contain a 1
-    public TreeNode checker(TreeNode root) {
-        if (!checkForOnes(root)) {
-            root = null;
-            return root;
-        }
-        
-        root.left = checker(root.left);
-        root.right = checker(root.right);
-        
-        return root;
+    boolean selfOne = root.val == 1;
+    boolean leftContainsOne = helper(root.left);
+    boolean rightContainsOne = helper(root.right);
+    if (!leftContainsOne) {
+      root.left = null;
     }
-
-// Checks for a 1 in the node
-    public boolean checkForOnes(TreeNode root) {
-        if (root == null) return false;
-        if (root.val == 1) return true;
-        
-        return checkForOnes(root.left) || checkForOnes(root.right);
+    if (!rightContainsOne) {
+      root.right = null;
     }
+    return selfOne || leftContainsOne || rightContainsOne;
+  }
 }

From b7ad572a6ca8913fb191ed5c47f36a8e19ae841d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 10 Jan 2022 14:47:09 -0800
Subject: [PATCH 0682/2175] Create Maximum Number of Coins You Can Get.java

---
 Medium/Maximum Number of Coins You Can Get.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Maximum Number of Coins You Can Get.java

diff --git a/Medium/Maximum Number of Coins You Can Get.java b/Medium/Maximum Number of Coins You Can Get.java
new file mode 100644
index 00000000..7642d7e2
--- /dev/null
+++ b/Medium/Maximum Number of Coins You Can Get.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int maxCoins(int[] piles) {
+    Arrays.sort(piles);
+    int n = piles.length;
+    int maxCoinCount = 0;
+    for (int i = n / 3; i < n; i += 2) {
+      maxCoinCount += piles[i];
+    }
+    return maxCoinCount;
+  }
+}

From 238d0fc0e1605b9c0dd3e98ba3a03de87e193b08 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 10 Jan 2022 16:36:52 -0800
Subject: [PATCH 0683/2175] Create Maximum Nesting Depth of Two Valid
 Parentheses Strings.java

---
 ... Depth of Two Valid Parentheses Strings.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java

diff --git a/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java b/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java
new file mode 100644
index 00000000..2907c330
--- /dev/null
+++ b/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int[] maxDepthAfterSplit(String seq) {
+    int[] maxDepth = new int[seq.length()];
+    int currDepth = 0;
+    for (int i = 0; i < seq.length(); i++) {
+      if (seq.charAt(i) == '(') {
+        currDepth++;
+      }
+      System.out.println(i + " " + seq.charAt(i) + " " + currDepth);
+      maxDepth[i] = currDepth % 2;
+      if (seq.charAt(i) != '(') {
+        currDepth--;
+      }
+    }
+    return maxDepth;
+  }
+}

From 2dc459f680ec26720913b74f968bc48de1febcd7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 11 Jan 2022 10:06:35 -0800
Subject: [PATCH 0684/2175] Update Sum of Root To Leaf Binary Numbers.java

---
 Easy/Sum of Root To Leaf Binary Numbers.java | 26 +++++++++-----------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/Easy/Sum of Root To Leaf Binary Numbers.java b/Easy/Sum of Root To Leaf Binary Numbers.java
index 135a6c6a..48133053 100644
--- a/Easy/Sum of Root To Leaf Binary Numbers.java	
+++ b/Easy/Sum of Root To Leaf Binary Numbers.java	
@@ -15,32 +15,30 @@
  */
 class Solution {
   public int sumRootToLeaf(TreeNode root) {
-    int[] sum = {0};
-    helper(root, new StringBuilder(), sum);
-    return sum[0];
+    int[] result = {0};
+    helper(root, new StringBuilder(), result);
+    return result[0];
   }
   
-  private void helper(TreeNode root, StringBuilder sb, int[] sum) {
+  private void helper(TreeNode root, StringBuilder sb, int[] result) {
     if (root == null) {
       return;
     }
     sb.append(root.val);
     if (root.left == null && root.right == null) {
-      sum[0] += getDecimalValue(sb.toString());
-    }
-    else {
-      helper(root.left, new StringBuilder(sb.toString()), sum);
-      helper(root.right, new StringBuilder(sb.toString()), sum);
+      result[0] += getDecimalValue(sb.toString());
+      return;
     }
+    helper(root.left, new StringBuilder(sb.toString()), result);
+    helper(root.right, new StringBuilder(sb.toString()), result);
   }
   
   private int getDecimalValue(String s) {
-    int val = 0;
-    int mul = 1;
+    int value = 0;
+    int powerOfTwo = 0;
     for (int i = s.length() - 1; i >= 0; i--) {
-      val += mul * (s.charAt(i) == '1' ? 1 : 0);
-      mul *= 2;
+      value += ((int) Math.pow(2, powerOfTwo++)) * Character.getNumericValue(s.charAt(i));
     }
-    return val;
+    return value;
   }
 }

From a774b9af9b0ff11da1051edded7cde6a36123654 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 11 Jan 2022 17:16:54 -0800
Subject: [PATCH 0685/2175] Update Insert into a Binary Search Tree.java

---
 Medium/Insert into a Binary Search Tree.java | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/Medium/Insert into a Binary Search Tree.java b/Medium/Insert into a Binary Search Tree.java
index 30e5ce41..7131fd50 100644
--- a/Medium/Insert into a Binary Search Tree.java	
+++ b/Medium/Insert into a Binary Search Tree.java	
@@ -12,16 +12,14 @@
  *         this.right = right;
  *     }
  * }
- */
+*/
 class Solution {
   public TreeNode insertIntoBST(TreeNode root, int val) {
     if (root == null) {
       return new TreeNode(val);
-    }
-    if (root.val < val) {
+    } else if (root.val < val) {
       root.right = insertIntoBST(root.right, val);
-    }
-    else {
+    } else {
       root.left = insertIntoBST(root.left, val);
     }
     return root;

From 0481fdb4f2cb75b6af08a231b19a47f63156681f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Jan 2022 20:11:59 -0800
Subject: [PATCH 0686/2175] Update Minimum Number of Arrows to Burst
 Balloons.java

---
 ...um Number of Arrows to Burst Balloons.java | 26 +++++--------------
 1 file changed, 7 insertions(+), 19 deletions(-)

diff --git a/Medium/Minimum Number of Arrows to Burst Balloons.java b/Medium/Minimum Number of Arrows to Burst Balloons.java
index b801e00b..a00d9274 100644
--- a/Medium/Minimum Number of Arrows to Burst Balloons.java	
+++ b/Medium/Minimum Number of Arrows to Burst Balloons.java	
@@ -1,26 +1,14 @@
 class Solution {
   public int findMinArrowShots(int[][] points) {
-    if (points.length == 0) {
-      return 0;
-    }
-    Arrays.sort(points, new Comparator<int[]>(){
-      public int compare(int[] p1, int[] p2) {
-        int c = p1[0] - p2[0];
-        if (c != 0) {
-          return c;
-        }
-        return p1[1] - p2[1];
-      }
-    });
-    int end = points[0][1];
-    int count = 1;
-    for (int i = 1; i < points.length; i++) {
-      if (points[i][0] <= end) {
-        end = Math.min(end, points[i][1]);
-        continue;
+    Arrays.sort(points, Comparator.comparingInt((int[] o) -> o[1]));
+    int count = 0;
+    int idx = 0;
+    while (idx < points.length) {
+      int currEnd = points[idx][1];
+      while (idx < points.length && points[idx][0] <= currEnd) {
+        idx++;
       }
       count++;
-      end = points[i][1];
     }
     return count;
   }

From 58ab07d1e09e9ec40a361ab7daf3218e0cd0e0fa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 13 Jan 2022 09:46:29 -0800
Subject: [PATCH 0687/2175] Update Number of segments in a String.java

---
 Easy/Number of segments in a String.java | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/Easy/Number of segments in a String.java b/Easy/Number of segments in a String.java
index 1ecd407e..2139e560 100644
--- a/Easy/Number of segments in a String.java	
+++ b/Easy/Number of segments in a String.java	
@@ -1,14 +1,11 @@
 class Solution {
-    public int countSegments(String str) {
-        String[] arr = str.split("\\s+");
-        
-        int count = 0;
-        for (String s : arr) {
-            if ((!s.equals("\\s+")) && s.length() > 0) {
-                count++;
-            }
-        }
-        
-        return count;
+  public int countSegments(String s) {
+    int count = 0;
+    for (int i = 0; i < s.length(); i++) {
+      if (s.charAt(i) != ' ' && (i == 0 || s.charAt(i - 1) == ' ')) {
+        count++;
+      }
     }
+    return count;
+  }
 }

From 66cb6a232fd8ef443263ffaa5688c5a43590e0bd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 13 Jan 2022 10:23:37 -0800
Subject: [PATCH 0688/2175] Update Perfect Number.java

---
 Easy/Perfect Number.java | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/Easy/Perfect Number.java b/Easy/Perfect Number.java
index 5afc8d1c..6ce680f2 100644
--- a/Easy/Perfect Number.java	
+++ b/Easy/Perfect Number.java	
@@ -1,16 +1,18 @@
 class Solution {
-    public boolean checkPerfectNumber(int num) {
-        if (num == 1) return false;
-        int sum = 0;
-        int i = 2;
-        while (i <= Math.sqrt(num)) {
-            if (num%i == 0) {
-                sum += i + num/i;
-            }
-            i++;
-        }
-        sum++;
-        
-        return sum == num;
+  public boolean checkPerfectNumber(int num) {
+    if (num == 1) {
+      return false;
+    } 
+    return getDivisorSum(num) == num;
+  }
+
+  private int getDivisorSum(int num) {
+    int sum = 0;
+    for (int i = 2; i <= Math.sqrt(num); i++) {
+      if (num % i == 0) {
+        sum += i + num / i;
+      }
     }
+    return sum + 1;
+  }
 }

From 94f87284da0f235428ad0256b502c373ebb5339b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 13 Jan 2022 16:27:59 -0800
Subject: [PATCH 0689/2175] Update String to Integer(atoi).java

---
 Medium/String to Integer(atoi).java | 49 +++++++++++------------------
 1 file changed, 19 insertions(+), 30 deletions(-)

diff --git a/Medium/String to Integer(atoi).java b/Medium/String to Integer(atoi).java
index 9d2aaf81..54fc622d 100644
--- a/Medium/String to Integer(atoi).java	
+++ b/Medium/String to Integer(atoi).java	
@@ -1,34 +1,23 @@
 class Solution {
-    public int myAtoi(String str) {
-        if (str.length() == 0) {
-            return 0;
-        }
-        
-        int idx = 0;
-        int n = str.length();
-        int sign = 1;
-        while (idx < n && str.charAt(idx) == ' ') {
-            idx++;
-        }
-        
-        if (idx < n && (str.charAt(idx) == '-' || str.charAt(idx) == '+')) {
-            sign = str.charAt(idx) == '-' ? -1 : 1;
-            idx++;
-        }
-        
-        long num = 0;
-        while (idx < n && Character.isDigit(str.charAt(idx))) {
-            num = num * 10 + Character.getNumericValue(str.charAt(idx++));
-            
-            if ((sign == 1 && num > Integer.MAX_VALUE) || (-num < Integer.MIN_VALUE)) {
-                return getOverflowValue(sign);
-            }
-        }
-        
-        return sign * (int) num;
+  public int myAtoi(String s) {
+    int idx = 0;
+    int n = s.length();
+    while (idx < n && s.charAt(idx) == ' ') {
+      idx++;
     }
-    
-    private int getOverflowValue(int sign) {
-        return sign == -1 ? Integer.MIN_VALUE : Integer.MAX_VALUE;
+    int sign = 1;
+    if (idx < n && (s.charAt(idx) == '+' || s.charAt(idx) == '-')) {
+      sign = s.charAt(idx++) == '-' ? -1 : 1;
     }
+    long num = 0;
+    while (idx < n && Character.isDigit(s.charAt(idx))) {
+      num = num * 10 + Character.getNumericValue(s.charAt(idx++));
+      if (sign == 1 && num > Integer.MAX_VALUE) {
+        return Integer.MAX_VALUE;
+      } else if (sign == -1 && num * sign < Integer.MIN_VALUE) {
+        return Integer.MIN_VALUE;
+      }
+    }
+    return (int) (num * sign);
+  }
 }

From dad3df38ae8e94314ad2ea7cd3474914beddf0b6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 14 Jan 2022 13:23:05 -0800
Subject: [PATCH 0690/2175] Create Maximize Sum Of Array After K Negations.java

---
 .../Maximize Sum Of Array After K Negations.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Maximize Sum Of Array After K Negations.java

diff --git a/Easy/Maximize Sum Of Array After K Negations.java b/Easy/Maximize Sum Of Array After K Negations.java
new file mode 100644
index 00000000..12201a97
--- /dev/null
+++ b/Easy/Maximize Sum Of Array After K Negations.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int largestSumAfterKNegations(int[] nums, int k) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    int sum = 0;
+    for (int num : nums) {
+      pq.add(num);
+      sum += num;
+    }
+    while (k-- > 0) {
+      sum -= pq.peek();
+      sum += -1 * pq.peek();
+      pq.add(-1 * pq.poll());
+    }
+    return sum;
+  }
+}

From 9238d70f2576328f252bfee6357b1799d8f39c7d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 15 Jan 2022 17:14:16 -0800
Subject: [PATCH 0691/2175] Update Maximum Nesting Depth of Two Valid
 Parentheses Strings.java

---
 .../Maximum Nesting Depth of Two Valid Parentheses Strings.java  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java b/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java
index 2907c330..444efeb0 100644
--- a/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java	
+++ b/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java	
@@ -6,7 +6,6 @@ public int[] maxDepthAfterSplit(String seq) {
       if (seq.charAt(i) == '(') {
         currDepth++;
       }
-      System.out.println(i + " " + seq.charAt(i) + " " + currDepth);
       maxDepth[i] = currDepth % 2;
       if (seq.charAt(i) != '(') {
         currDepth--;

From efbcf7fa53b3ee590a16fc0c3969f436b48d38f4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 15 Jan 2022 20:18:41 -0800
Subject: [PATCH 0692/2175] Create Divide a String Into Groups of Size k.java

---
 ...Divide a String Into Groups of Size k.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Divide a String Into Groups of Size k.java

diff --git a/Easy/Divide a String Into Groups of Size k.java b/Easy/Divide a String Into Groups of Size k.java
new file mode 100644
index 00000000..c37d5a6d
--- /dev/null
+++ b/Easy/Divide a String Into Groups of Size k.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public String[] divideString(String s, int k, char fill) {
+    int n = s.length() % k  == 0 ? s.length() / k : s.length() / k + 1;
+    String[] result = new String[n];
+    int idx = 0;
+    for (int i = 0; i < n; i++) {
+      String split = s.substring(idx, Math.min(idx + k, s.length()));
+      result[i] = formString(split, k, fill);
+      idx += k;
+    }
+    return result;
+  }
+
+  private String formString(String s, int k, char fill) {
+    if (s.length() != k) {
+      return s + String.join("", Collections.nCopies(k - s.length(), String.valueOf(fill)));
+    }
+    return s;
+  }
+}

From bd553bb0271362f06ea0090e62ca17e775b5dd23 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 16 Jan 2022 08:11:26 -0800
Subject: [PATCH 0693/2175] Create Minimum Moves to Reach Target Score.java

---
 Medium/Minimum Moves to Reach Target Score.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Minimum Moves to Reach Target Score.java

diff --git a/Medium/Minimum Moves to Reach Target Score.java b/Medium/Minimum Moves to Reach Target Score.java
new file mode 100644
index 00000000..c9bfdfc0
--- /dev/null
+++ b/Medium/Minimum Moves to Reach Target Score.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int minMoves(int target, int maxDoubles) {
+    int numOfSteps = 0;
+    while (target > 0 && maxDoubles > 0) {
+      if (target % 2 == 0) {
+        maxDoubles--;
+        target /= 2;
+      } else {
+        target--;
+      }
+      numOfSteps++;
+    }
+    return numOfSteps + target - 1;
+  }
+}

From 23daad50cb29d21c438710bc5e04fa0234fe58c1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 16 Jan 2022 11:12:25 -0800
Subject: [PATCH 0694/2175] Create Find if Path Exists in Graph.java

---
 Easy/Find if Path Exists in Graph.java | 28 ++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Easy/Find if Path Exists in Graph.java

diff --git a/Easy/Find if Path Exists in Graph.java b/Easy/Find if Path Exists in Graph.java
new file mode 100644
index 00000000..cfa38aaa
--- /dev/null
+++ b/Easy/Find if Path Exists in Graph.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public boolean validPath(int n, int[][] edges, int start, int end) {
+    Map<Integer, Set<Integer>> graph = new HashMap<>();
+    for (int[] edge : edges) {
+      graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+      graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    }
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(start);
+    Set<Integer> visited = new HashSet<>();
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int removed = queue.remove();
+        if (removed == end) {
+          return true;
+        }
+        visited.add(removed);
+        for (Integer connection : graph.getOrDefault(removed, new HashSet<>())) {
+          if (!visited.contains(connection)) {
+            queue.add(connection);
+          }
+        }
+      }
+    }
+    return false;
+  }
+}

From fca506afa3d58ed5b6953a0874cf42f68ef8385c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 17 Jan 2022 08:37:41 -0800
Subject: [PATCH 0695/2175] Update Masking Personal Information.java

---
 Medium/Masking Personal Information.java | 104 +++++++----------------
 1 file changed, 31 insertions(+), 73 deletions(-)

diff --git a/Medium/Masking Personal Information.java b/Medium/Masking Personal Information.java
index 841240a6..1d0559dc 100644
--- a/Medium/Masking Personal Information.java	
+++ b/Medium/Masking Personal Information.java	
@@ -1,76 +1,34 @@
 class Solution {
-    public static String maskPII(String S) {
-        if (S.length() == 0) {
-            return S;
-        }
-        
-        if (S.indexOf('@') != -1) {
-            return formatEmail(S);
-        }
-        else {
-            return formatNumber(S);
-        }
-    }
-
-    private static String formatNumber(String s) {
-        StringBuilder sb = new StringBuilder();
-        int digitCount = getDigitCount(s);
-
-        if (digitCount > 10) {
-            sb.append("+");
-            int extra = digitCount - 10;
-            while (extra-- > 0) {
-                sb.append("*");
-            }
-            sb.append("-");
-        }
-        sb.append("***-***-");
-
-        StringBuilder last4 = new StringBuilder();
-        for (int i=s.length()-1; i>=0; i--) {
-            if (Character.isDigit(s.charAt(i))) {
-                last4.append(s.charAt(i));
-            }
-
-            if (last4.length() == 4) {
-                break;
-            }
-        }
-
-        sb.append(last4.reverse().toString());
-
-        return sb.toString();
-    }
-
-    private static int getDigitCount(String s) {
-        char[] chars = s.toCharArray();
-        int count = 0;
-
-        for (char c : chars) {
-            if (Character.isDigit(c)) {
-                count++;
-            }
-        }
-
-        return count;
-    }
-
-    private static String formatEmail(String s) {
-        int idx = s.indexOf('@');
-        int revStart = idx - 1;
-        while (revStart >= 0 && Character.isLetter(s.charAt(revStart))) {
-            revStart--;
-        }
-
-        StringBuilder sb = new StringBuilder();
-
-        sb.
-        append(s.substring(0, revStart+1)).
-        append(Character.toLowerCase(s.charAt(revStart + 1))).
-        append("*****").
-        append(Character.toLowerCase(s.charAt(s.indexOf('@') - 1))).
-        append(s.substring(s.indexOf('@')));
-
-        return sb.toString().toLowerCase();
+  public String maskPII(String s) {
+    return s.indexOf('@') != -1 ? maskEmail(s) : maskPhoneNumber(s);
+  }
+
+  private String maskPhoneNumber(String phoneNumber) {
+    StringBuilder digits = new StringBuilder();
+    for (char c : phoneNumber.toCharArray()) {
+      if (Character.isDigit(c)) {
+        digits.append(c);
+      }
     }
+    return getMaskedAreaCode(digits.length()) + "***-***-" + digits.substring(digits.length() - 4);
+  }
+
+  private String getMaskedAreaCode(int phoneNumberLength) {
+    return switch (phoneNumberLength) {
+      case 10 -> "";
+      case 11 -> "+*-";
+      case 12 -> "+**-";
+      case 13 -> "+***-";
+      default -> null;
+    };
+  }
+
+  private String maskEmail(String email) {
+    String[] split = email.split("@");
+    String name = split[0];
+    String domain = split[1].toLowerCase();
+    String maskedName = Character.toLowerCase(name.charAt(0)) + String.join("", Collections.nCopies(5, "*"))
+        + Character.toLowerCase(name.charAt(name.length() - 1));
+    return maskedName + "@" + domain;
+  }
 }

From 480bba68447e9bdf7d386af61e39af751aabbc07 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Jan 2022 07:58:21 -0800
Subject: [PATCH 0696/2175] Update Can Place Flowers.java

---
 Easy/Can Place Flowers.java | 41 +++++++++++++++----------------------
 1 file changed, 17 insertions(+), 24 deletions(-)

diff --git a/Easy/Can Place Flowers.java b/Easy/Can Place Flowers.java
index c02aa20b..df188af0 100644
--- a/Easy/Can Place Flowers.java	
+++ b/Easy/Can Place Flowers.java	
@@ -1,28 +1,21 @@
 class Solution {
-    public boolean canPlaceFlowers(int[] flowerbed, int n) {
-        for (int i=0;i<flowerbed.length;i++) {
-            if (i == 0 && flowerbed.length > 1) {
-                if (flowerbed[i] == 0 && flowerbed[i+1] == 0) {
-                    flowerbed[i] = 1;
-                    n--;
-                }
-            }
-            else if (flowerbed[i] == 0 && flowerbed.length > 2 && flowerbed[i-1] == 0 && i+1 < flowerbed.length && flowerbed[i+1] == 0) {
-                flowerbed[i] = 1;
-                n--;
-            }
-            else if (i == flowerbed.length-1 && flowerbed.length > 1) {
-                if (flowerbed[i-1] == 0 && flowerbed[i] == 0) {
-                    flowerbed[i] = 1;
-                    n--;
-                }
-            }
-            else if (flowerbed.length == 1 && flowerbed[0] == 0) {
-                n--;
-            }
-            
-            if (n <= 0) break;
+  public boolean canPlaceFlowers(int[] flowerbed, int n) {
+    for (int i = 0; i < flowerbed.length && n > 0; i++) {
+      if (flowerbed[i] == 0) {
+        if (i == 0 && (i + 1 < flowerbed.length && flowerbed[i + 1] == 0)
+            || flowerbed.length == 1) {
+          flowerbed[i] = 1;
+          n--;
+        } else if (i == flowerbed.length - 1 && i - 1 >= 0 && flowerbed[i - 1] == 0) {
+          flowerbed[i] = 1;
+          n--;
+        } else if (i + 1 < flowerbed.length && i - 1 >= 0 && flowerbed[i + 1] == 0
+            && flowerbed[i - 1] == 0) {
+          flowerbed[i] = 1;
+          n--;
         }
-        return n<=0;
+      }
     }
+    return n == 0;
+  }
 }

From 301a5b147bbf8af6e26075339fafdb178d215200 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 19 Jan 2022 07:54:39 -0800
Subject: [PATCH 0697/2175] Update Zigzag Iterator.java

---
 Medium/Zigzag Iterator.java | 69 ++++++++++++++-----------------------
 1 file changed, 26 insertions(+), 43 deletions(-)

diff --git a/Medium/Zigzag Iterator.java b/Medium/Zigzag Iterator.java
index 442497c1..1b4f8554 100644
--- a/Medium/Zigzag Iterator.java	
+++ b/Medium/Zigzag Iterator.java	
@@ -1,52 +1,35 @@
 public class ZigzagIterator {
-    
-    List<Integer> l1;
-    List<Integer> l2;
-    int start1;
-    int start2;
-    int end1;
-    int end2;
-    boolean flag;
-    
-    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
-        l1 = v1;
-        l2 = v2;
-        start1 = 0;
-        start2 = 0;
-        end1 = l1.size();
-        end2 = l2.size();
-        flag = true;
-    }
 
-    public int next() {
-        if (start1 < end1 && start2 < end2) {
-            int ans = -1;
-            if (flag) {
-                ans = l1.get(start1);
-                start1++;
-                flag = !flag;
-            }
-            else {
-                ans = l2.get(start2);
-                start2++;
-                flag = !flag;
-            }
-            
-            return ans;
-        }
-        else if (start1 < end1) {
-            return l1.get(start1++);
-        }
-        else {
-            return l2.get(start2++);
-        }
-    }
+  private final List<Integer> listOne;
+  private final List<Integer> listTwo;
+  int idxOne;
+  int idxTwo;
+  boolean pickFromListOne;
+  public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
+    this.listOne = v1;
+    this.listTwo = v2;
+    this.idxOne = 0;
+    this.idxTwo = 0;
+    this.pickFromListOne = true;
+  }
 
-    public boolean hasNext() {
-        return !(start1 == end1 && start2 == end2);
+  public int next() {
+    if ((pickFromListOne && idxOne < listOne.size()) || (!pickFromListOne
+        && idxTwo == listTwo.size())) {
+      pickFromListOne = !pickFromListOne;
+      return listOne.get(idxOne++);
     }
+    pickFromListOne = !pickFromListOne;
+    return listTwo.get(idxTwo++);
+  }
+
+  public boolean hasNext() {
+    return idxOne < listOne.size() || idxTwo < listTwo.size();
+  }
 }
 
+
+
 /**
  * Your ZigzagIterator object will be instantiated and called as such:
  * ZigzagIterator i = new ZigzagIterator(v1, v2);

From 4ae85605eee3e991be83303658a0b5dd997e72d1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 19 Jan 2022 13:43:50 -0800
Subject: [PATCH 0698/2175] Update Unique Word Abbrevation.java

---
 Medium/Unique Word Abbrevation.java | 54 ++++++++++++-----------------
 1 file changed, 23 insertions(+), 31 deletions(-)

diff --git a/Medium/Unique Word Abbrevation.java b/Medium/Unique Word Abbrevation.java
index 096a2b2a..4cb79291 100644
--- a/Medium/Unique Word Abbrevation.java	
+++ b/Medium/Unique Word Abbrevation.java	
@@ -1,41 +1,33 @@
 class ValidWordAbbr {
 
-    Map<String, String> map;
-    public ValidWordAbbr(String[] dictionary) {
-        map = new HashMap<>();
-
-        for (String word : dictionary) {
-            String abbr = getAbbr(word);
-            if (map.containsKey(abbr)) {
-                if (!map.get(abbr).equals(word)) {
-                    map.put(abbr, "");
-                }
-            }
-            else {
-                map.put(abbr, word);
-            }
-        }
-    }
-
-    public boolean isUnique(String word) {
-        String abbr = getAbbr(word);
-        return !map.containsKey(abbr) || map.get(abbr).equals(word);
+  private final Map<String, String> abbreviationToWordMap;
+
+  public ValidWordAbbr(String[] dictionary) {
+    this.abbreviationToWordMap = new HashMap<>();
+    for (String word : dictionary) {
+      String abbreviation = buildAbbreviation(word);
+      if (this.abbreviationToWordMap.containsKey(abbreviation) && 
+          !this.abbreviationToWordMap.get(abbreviation).equals(word)) {
+        this.abbreviationToWordMap.put(abbreviation, "");
+      } else {
+        this.abbreviationToWordMap.put(abbreviation, word);
+      }
     }
+  }
 
-    private String getAbbr(String word) {
-        if (word.length() <= 2) {
-            return word;
-        }
+  public boolean isUnique(String word) {
+    String abbreviation = buildAbbreviation(word);
+    return !this.abbreviationToWordMap.containsKey(abbreviation) || this.abbreviationToWordMap.get(
+        abbreviation).equals(word);
+  }
 
-        int num = word.length() - 2;
-        StringBuilder sb = new StringBuilder();
-        sb.append(word.charAt(0)).append(String.valueOf(num)).append(word.charAt(word.length()-1));
-
-        return sb.toString();
+  private String buildAbbreviation(String s) {
+    if (s.length() <= 2) {
+      return s;
     }
+    return s.charAt(0) + String.valueOf(s.length() - 2) + s.charAt(s.length() - 1);
+  }
 }
-
-
 /**
  * Your ValidWordAbbr object will be instantiated and called as such:
  * ValidWordAbbr obj = new ValidWordAbbr(dictionary);

From d7067fe4177e0acccfc5d9b4bae93c1f50357da0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 19 Jan 2022 16:28:20 -0800
Subject: [PATCH 0699/2175] Update Koko Eating Bananas.java

---
 Medium/Koko Eating Bananas.java | 46 ++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/Medium/Koko Eating Bananas.java b/Medium/Koko Eating Bananas.java
index f0a7f6cb..e4bab284 100644
--- a/Medium/Koko Eating Bananas.java	
+++ b/Medium/Koko Eating Bananas.java	
@@ -1,33 +1,33 @@
 class Solution {
-  public int minEatingSpeed(int[] piles, int H) {
-    int maxSize = piles[0];
-    for (int pile : piles) {
-      maxSize = Math.max(pile, maxSize);
+  public int minEatingSpeed(int[] piles, int h) {
+    int minBananaCount = 1;
+    int maxBananaCount = maxFromPile(piles);
+    while (minBananaCount < maxBananaCount) {
+      int mid = (minBananaCount + maxBananaCount) / 2;
+      if (canFinishPile(piles, mid, h)) {
+        maxBananaCount = mid;
+      } else {
+        minBananaCount = mid + 1;
+      }
     }
-    return helper(piles, H, 1, maxSize);
+    return minBananaCount;
   }
   
-  private int helper(int[] piles, int H, int start, int end) {
-    while (start < end) {
-      int mid = (start + end) / 2;
-      if (isPossible(piles, H, mid)) {
-        end = mid; 
-      }
-      else {
-        start = mid + 1;
-      }
+  private boolean canFinishPile(int[] piles, int bananaPerHour, int totalHours) {
+    int totalTime = 0;
+    for (int pile : piles) {
+      int numOfHours = pile / bananaPerHour; 
+      totalTime += numOfHours == 0 ? 1 : numOfHours;
+      totalTime += numOfHours > 0 && pile % bananaPerHour != 0 ? 1 : 0;
     }
-    return start;
+    return totalTime <= totalHours;
   }
   
-  private boolean isPossible(int[] piles, int H, int check) {
-    int numOfHours = 0;
-    for (int pile : piles) {
-      int quot = pile / check; 
-      numOfHours += quot == 0 ? 1 : quot;
-      numOfHours += quot > 0 && pile % check != 0 ? 1 : 0;
+  private int maxFromPile(int[] piles) {
+    int maxCount = piles[0];
+    for (int i = 1; i < piles.length; i++) {
+      maxCount = Math.max(maxCount, piles[i]);
     }
-    return numOfHours <= H;
+    return maxCount;
   }
 }
-

From d1ae41db0bd1ea511f2e4db843d1ec1ee5760010 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 20 Jan 2022 09:47:11 -0800
Subject: [PATCH 0700/2175] Update Design Compressed String Iterator.java

---
 Easy/Design Compressed String Iterator.java | 86 +++++++++------------
 1 file changed, 37 insertions(+), 49 deletions(-)

diff --git a/Easy/Design Compressed String Iterator.java b/Easy/Design Compressed String Iterator.java
index 8d128e75..a13e5d9e 100644
--- a/Easy/Design Compressed String Iterator.java	
+++ b/Easy/Design Compressed String Iterator.java	
@@ -1,61 +1,49 @@
 class StringIterator {
-    int letterPointer = 0;
-    int numberPointer = letterPointer + 1;
-    int counter;
-    char c;
-    String s;
-    StringBuilder num;
 
-    public StringIterator(String compressedString) {
-        s = compressedString;
-        c = s.charAt(letterPointer);
-        
-        num = new StringBuilder();
-        while (numberPointer<s.length() && Character.isDigit(s.charAt(numberPointer))) {
-            num.append(s.charAt(numberPointer));
-            numberPointer++;
-        }
-        counter = Integer.parseInt(num.toString());
+  private Integer charIdx;
+  private Integer currCount;
+  private Integer counterIdx;
+  private String s;
 
-        letterPointer = numberPointer;
-        numberPointer = letterPointer + 1;
-    }
-
-    public char next() {
-        if (counter == 0) {
-            if (numberPointer <= s.length()-1) {
-                c = s.charAt(letterPointer);
-                num = new StringBuilder();
-                while (numberPointer<s.length() && Character.isDigit(s.charAt(numberPointer))) {
-                    num.append(s.charAt(numberPointer));
-                    numberPointer++;
-                }
-                counter = Integer.parseInt(num.toString()) - 1;
-
-                letterPointer = numberPointer;
-                numberPointer = letterPointer + 1;
-            }
-            else {
-                c = ' ';
-            }
-        }
-        else {
-            counter--;
-        }
+  public StringIterator(String compressedString) {
+    this.s = compressedString;
+    updateCurrCount();
+  }
 
-        return c;
+  public char next() {
+    if (!hasNext()) {
+      return ' ';
     }
+    this.currCount--;
+    return s.charAt(this.charIdx);
+  }
 
-    public boolean hasNext() {
-        if (counter == 0) {
-            if (numberPointer > s.length()-1) {
-                return false;
-            }
-        }
-        return true;
+  public boolean hasNext() {
+    updateCurrCount();
+    return this.currCount > 0;
+  }
+  
+  private void updateCurrCount() {
+    if (this.currCount != null && this.currCount == 0) {
+      this.charIdx = this.counterIdx;
+      this.counterIdx = this.charIdx + 1;
     }
+    if (this.currCount == null) {
+      this.charIdx = 0;
+      this.counterIdx = this.charIdx + 1;
+      this.currCount = 0;
+    }
+    if (this.currCount == 0) {
+      while (this.counterIdx < this.s.length()
+          && Character.isDigit(this.s.charAt(this.counterIdx))) {
+        this.currCount =
+            this.currCount * 10 + Character.getNumericValue(this.s.charAt(this.counterIdx++));
+      }
+    }
+  }
 }
 
+
 /**
  * Your StringIterator object will be instantiated and called as such:
  * StringIterator obj = new StringIterator(compressedString);

From 9e9fd57ab6ca84155aa5c98a0829ea249dbcb4b7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 20 Jan 2022 13:37:41 -0800
Subject: [PATCH 0701/2175] Update Design Search Autocomplete System.java

---
 Hard/Design Search Autocomplete System.java | 116 +++++++++-----------
 1 file changed, 54 insertions(+), 62 deletions(-)

diff --git a/Hard/Design Search Autocomplete System.java b/Hard/Design Search Autocomplete System.java
index 98888b69..c4c15c9e 100644
--- a/Hard/Design Search Autocomplete System.java	
+++ b/Hard/Design Search Autocomplete System.java	
@@ -1,84 +1,76 @@
 class AutocompleteSystem {
-  Map<String, Integer> map;
-  Node root;
-  Node currNode;
+
+  private final TrieNode root;
+  private TrieNode queryNode;
+  private final Map<String, Integer> popularityMap;
   StringBuilder sb;
   boolean invalidQuery;
+
   public AutocompleteSystem(String[] sentences, int[] times) {
-    map = new HashMap<>();
-    root = new Node('-');
+    root = new TrieNode();
+    this.popularityMap = new HashMap<>();
     for (int i = 0; i < sentences.length; i++) {
-      addSentence(sentences[i], 0, root);
-      map.put(sentences[i], map.getOrDefault(sentences[i], 0) + times[i]);
+      indexSentence(sentences[i], root);
+      this.popularityMap.put(
+          sentences[i], this.popularityMap.getOrDefault(sentences[i], 0) + times[i]);
     }
-    currNode = root;
-    invalidQuery = false;
-    sb = new StringBuilder();
+    this.queryNode = root;
+    this.sb = new StringBuilder();
+    this.invalidQuery = false;
   }
-  
-  private void addSentence(String s, int idx, Node root) {
-    if (idx == s.length()) {
-      return;
-    }
-    char c = s.charAt(idx);
-    if (!root.children.containsKey(c)) {
-      root.children.put(c, new Node(c));
+
+  private void indexSentence(String sentence, TrieNode root) {
+    for (char c : sentence.toCharArray()) {
+      if (!root.children.containsKey(c)) {
+        root.children.put(c, new TrieNode());
+      }
+      root = root.children.get(c);
+      root.sentences.add(sentence);
     }
-    Node node = root.children.get(c);
-    node.possibleSentences.add(s);
-    addSentence(s, idx + 1, node);
   }
 
   public List<String> input(char c) {
     if (c == '#') {
-      String s = sb.toString();
-      map.put(s, map.getOrDefault(s, 0) + 1);
-      addSentence(s, 0, root);
-      sb.setLength(0);
-      currNode = root;
-      invalidQuery = false;
+      cleanUp();
       return new ArrayList<>();
     }
-    sb.append(c);
-    if (!currNode.children.containsKey(c) || invalidQuery) {
-      invalidQuery = true;
+    this.sb.append(c);
+    if (!this.queryNode.children.containsKey(c) || invalidQuery) {
+      this.invalidQuery = true;
       return new ArrayList<>();
     }
-    else {
-      List<String> possibleSentences = new ArrayList<>();
-      currNode = currNode.children.get(c);
-      possibleSentences.addAll(currNode.possibleSentences);
-      return getTopThree(possibleSentences);
-    }
+    this.queryNode = this.queryNode.children.get(c);
+    return this.queryNode.sentences.stream()
+        .sorted(
+            (o1, o2) -> {
+              int c1 = popularityMap.get(o2).compareTo(popularityMap.get(o1));
+              if (c1 != 0) {
+                return c1;
+              }
+              return o1.compareTo(o2);
+            })
+        .limit(3)
+        .collect(Collectors.toList());
   }
-  
-  private List<String> getTopThree(List<String> list) {
-    Collections.sort(list, new Comparator<String>(){
-      public int compare(String s1, String s2) {
-        int c = map.get(s2) - map.get(s1);
-        if (c != 0) {
-          return c;
-        }
-        return s1.compareTo(s2);
-      }
-    });
-    List<String> ans = new ArrayList<>();
-    for (int i = 0; i < list.size() && ans.size() < 3; i++) {
-      ans.add(list.get(i));
-    }
-    return ans;
+
+  private void cleanUp() {
+    this.queryNode = root;
+    String inputString = this.sb.toString();
+    this.sb.setLength(0);
+    this.popularityMap.put(inputString, this.popularityMap.getOrDefault(inputString, 0) + 1);
+    this.invalidQuery = false;
+    indexSentence(inputString, root);
   }
-}
 
-class Node {
-  char c;
-  Map<Character, Node> children;
-  Set<String> possibleSentences;
-  
-  public Node(char c) {
-    this.c = c;
-    children = new HashMap<>();
-    possibleSentences = new HashSet<>();
+  private static class TrieNode {
+
+    private final Map<Character, TrieNode> children;
+    private final Set<String> sentences;
+
+    public TrieNode() {
+      this.children = new HashMap<>();
+      this.sentences = new HashSet<>();
+    }
   }
 }
 

From 738895581f0f0dc0e2da81f4c206c6e8c4e118d7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 21 Jan 2022 13:31:59 -0800
Subject: [PATCH 0702/2175] Update Logger Rate Limiter.java

---
 Easy/Logger Rate Limiter.java | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/Easy/Logger Rate Limiter.java b/Easy/Logger Rate Limiter.java
index 3e637371..6cdc1665 100644
--- a/Easy/Logger Rate Limiter.java	
+++ b/Easy/Logger Rate Limiter.java	
@@ -1,19 +1,16 @@
 class Logger {
-
-  /** Initialize your data structure here. */
-  Map<String, Integer> map;
+  
+  private final Map<String, Integer> logger;
+  
   public Logger() {
-    map = new HashMap<>();
+    this.logger = new HashMap<>();
   }
 
-  /** Returns true if the message should be printed in the given timestamp, otherwise returns false.
-      If this method returns false, the message will not be printed.
-      The timestamp is in seconds granularity. */
   public boolean shouldPrintMessage(int timestamp, String message) {
-    if (map.containsKey(message) && (timestamp - map.get(message)) < 10) {
+    if (this.logger.containsKey(message) && timestamp - this.logger.get(message) < 10) {
       return false;
     }
-    map.put(message, timestamp);
+    this.logger.put(message, timestamp);
     return true;
   }
 }

From 37796809e5a4e261c255e5f216060903b431daa2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 21 Jan 2022 17:15:41 -0800
Subject: [PATCH 0703/2175] Create Design In-Memory File System.java

---
 Hard/Design In-Memory File System.java | 111 +++++++++++++++++++++++++
 1 file changed, 111 insertions(+)
 create mode 100644 Hard/Design In-Memory File System.java

diff --git a/Hard/Design In-Memory File System.java b/Hard/Design In-Memory File System.java
new file mode 100644
index 00000000..9bc2ba8e
--- /dev/null
+++ b/Hard/Design In-Memory File System.java	
@@ -0,0 +1,111 @@
+class FileSystem {
+
+  private final FileNode root;
+
+  public FileSystem() {
+    this.root = new FileNode("ROOT", FileType.FOLDER);
+  }
+
+  /*
+   * If path is a file path, returns a list that only contains this file's name.
+   * If path is a directory path, returns the list of file and directory names in this directory.
+   * */
+  public List<String> ls(String path) {
+    String[] split = path.split("/");
+    FileNode currNode = root;
+    for (int i = 1; i < split.length; i++) {
+      currNode = currNode.subFiles.get(split[i]);
+    }
+    if (currNode.fileType.equals(FileType.FILE)) {
+      return List.of(currNode.value);
+    } else {
+      return currNode.subFiles.keySet().stream().sorted().collect(Collectors.toList());
+    }
+  }
+
+  /*
+   * Makes a new directory according to the given path. The given directory path does not exist.
+   * If the middle directories in the path do not exist, you should create them as well.
+   * */
+  public void mkdir(String path) {
+    String[] splits = path.split("/");
+    FileNode currNode = root;
+    for (int i = 1; i < splits.length; i++) {
+      String fileName = splits[i];
+      if (!currNode.subFiles.containsKey(fileName)) {
+        currNode.subFiles.put(fileName, new FileNode(fileName, FileType.FOLDER));
+      }
+      currNode = currNode.subFiles.get(fileName);
+    }
+  }
+
+  /*
+   * If filePath does not exist, creates that file containing given content.
+   * If filePath already exists, appends the given content to original content.
+   * */
+  public void addContentToFile(String filePath, String content) {
+    String[] splits = filePath.split("/");
+    FileNode currNode = root;
+    for (int i = 1; i < splits.length - 1; i++) {
+      String folderName = splits[i];
+      if (!currNode.subFiles.containsKey(folderName)) {
+        currNode.subFiles.put(folderName, new FileNode(folderName, FileType.FOLDER));
+      }
+      currNode = currNode.subFiles.get(folderName);
+    }
+    String fileName = splits[splits.length - 1];
+    if (!currNode.subFiles.containsKey(fileName) ||
+        !currNode.subFiles.get(fileName).fileType.equals(FileType.FILE)) {
+      currNode.subFiles.put(fileName, new FileNode(fileName, FileType.FILE));
+    }
+    currNode = currNode.subFiles.get(fileName);
+    currNode.addContentToFile(content);
+  }
+
+  /*
+   * Returns the content in the file at filePath.
+   * */
+  public String readContentFromFile(String filePath) {
+    String[] splits = filePath.split("/");
+    FileNode currNode = root;
+    for (int i = 1; i < splits.length; i++) {
+      String folderName = splits[i];
+      currNode = currNode.subFiles.get(folderName);
+    }
+    return currNode.fileContent.toString();
+  }
+
+  enum FileType {
+    FILE, FOLDER
+  }
+
+  static class FileNode {
+
+    private final String value;
+    private final Map<String, FileNode> subFiles;
+    private final FileType fileType;
+    private StringBuilder fileContent;
+
+    public FileNode(String value, FileType fileType) {
+      this.value = value;
+      this.fileType = fileType;
+      this.subFiles = new HashMap<>();
+    }
+
+    public void addContentToFile(String content) {
+      if (fileContent == null) {
+        fileContent = new StringBuilder();
+      }
+      fileContent.append(content);
+    }
+  }
+}
+
+/**
+ * Your FileSystem object will be instantiated and called as such:
+ * FileSystem obj = new FileSystem();
+ * List<String> param_1 = obj.ls(path);
+ * obj.mkdir(path);
+ * obj.addContentToFile(filePath,content);
+ * String param_4 = obj.readContentFromFile(filePath);
+ */

From c96964fa2648742f84a5a14ada47f5f59b2e8d12 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Jan 2022 09:07:56 -0800
Subject: [PATCH 0704/2175] Update Find Nearest Right Node in Binary Tree.java

---
 ...ind Nearest Right Node in Binary Tree.java | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/Medium/Find Nearest Right Node in Binary Tree.java b/Medium/Find Nearest Right Node in Binary Tree.java
index 0388eddd..5fd92c97 100644
--- a/Medium/Find Nearest Right Node in Binary Tree.java	
+++ b/Medium/Find Nearest Right Node in Binary Tree.java	
@@ -14,22 +14,15 @@
  * }
  */
 class Solution {
-  public TreeNode findNeartestRightNode(TreeNode root, TreeNode u) {
-    if (root == null) {
-      return null;
-    }
+  public TreeNode findNearestRightNode(TreeNode root, TreeNode u) {
     Queue<TreeNode> queue = new LinkedList<>();
     queue.add(root);
-    boolean found = false;
     while (!queue.isEmpty()) {
       int size = queue.size();
-      while (size-- > 0) {
+      while (size > 0) {
         TreeNode removed = queue.remove();
-        if (found) {
-          return removed;
-        }
-        if (removed == u) {
-          found = true;
+        if (removed.equals(u)) {
+          return size == 1 ? null : queue.peek();
         }
         if (removed.left != null) {
           queue.add(removed.left);
@@ -37,9 +30,7 @@ public TreeNode findNeartestRightNode(TreeNode root, TreeNode u) {
         if (removed.right != null) {
           queue.add(removed.right);
         }
-      }
-      if (found) {
-        break;
+        size--;
       }
     }
     return null;

From 9c93d39b4f4913741b462676211322106afe37f5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Jan 2022 09:53:16 -0800
Subject: [PATCH 0705/2175] Create Minimum Cost of Buying Candies With
 Discount.java

---
 ... Cost of Buying Candies With Discount.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Minimum Cost of Buying Candies With Discount.java

diff --git a/Easy/Minimum Cost of Buying Candies With Discount.java b/Easy/Minimum Cost of Buying Candies With Discount.java
new file mode 100644
index 00000000..71a2492b
--- /dev/null
+++ b/Easy/Minimum Cost of Buying Candies With Discount.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int minimumCost(int[] cost) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> o2 - o1);
+    for (int price : cost) {
+      pq.add(price);
+    }
+    int totalCost = 0;
+    while (!pq.isEmpty()) {
+      totalCost += pq.poll();
+      if (!pq.isEmpty()) {
+        totalCost += pq.poll();
+      }
+      if (!pq.isEmpty()) {
+        pq.poll();
+      }
+    }
+    return totalCost;
+  }
+}

From 1a9759bfe7f5871f6df4b8f9349939b5a8ad2654 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Jan 2022 21:11:09 -0800
Subject: [PATCH 0706/2175] Create Count Elements With Strictly Smaller and
 Greater Elements.java

---
 ...h Strictly Smaller and Greater Elements.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Count Elements With Strictly Smaller and Greater Elements.java

diff --git a/Easy/Count Elements With Strictly Smaller and Greater Elements.java b/Easy/Count Elements With Strictly Smaller and Greater Elements.java
new file mode 100644
index 00000000..42b3f09d
--- /dev/null
+++ b/Easy/Count Elements With Strictly Smaller and Greater Elements.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int countElements(int[] nums) {
+    int minValue = nums[0];
+    int maxValue = nums[0];
+    for (int num : nums) {
+      minValue = Math.min(minValue, num);
+      maxValue = Math.max(maxValue, num);
+    }
+    int count = 0;
+    for (int num : nums) {
+      if (num > minValue && num < maxValue) {
+        count++;
+      }
+    }
+    return count;
+  }
+}

From 5668ae787d571637fad6f195d2aabfb652f4917f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Jan 2022 21:17:36 -0800
Subject: [PATCH 0707/2175] Create Rearrange Array Elements by Sign.java

---
 Medium/Rearrange Array Elements by Sign.java | 21 ++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Rearrange Array Elements by Sign.java

diff --git a/Medium/Rearrange Array Elements by Sign.java b/Medium/Rearrange Array Elements by Sign.java
new file mode 100644
index 00000000..d2eb68e7
--- /dev/null
+++ b/Medium/Rearrange Array Elements by Sign.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int[] rearrangeArray(int[] nums) {
+    List<Integer> positive = new ArrayList<>();
+    List<Integer> negative = new ArrayList<>();
+    for (int num : nums) {
+      if (num > 0) {
+        positive.add(num);
+      } else {
+        negative.add(num);
+      }
+    }
+    int positiveIdx = 0;
+    int negativeIdx = 0;
+    boolean positiveFlag = true;
+    for (int i = 0; i < nums.length; i++) {
+      nums[i] = positiveFlag ? positive.get(positiveIdx++) : negative.get(negativeIdx++);
+      positiveFlag = !positiveFlag;
+    }
+    return nums;
+  }
+}

From aa25b4447f8a9fd4c06bff0e2391405bd9a8f54e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 Jan 2022 11:07:18 -0800
Subject: [PATCH 0708/2175] Update Sequential Digits.java

---
 Medium/Sequential Digits.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Medium/Sequential Digits.java b/Medium/Sequential Digits.java
index ab52770d..94cc1b23 100644
--- a/Medium/Sequential Digits.java	
+++ b/Medium/Sequential Digits.java	
@@ -2,17 +2,17 @@ class Solution {
   public List<Integer> sequentialDigits(int low, int high) {
     String bucket = "123456789";
     int n = 10;
-    List<Integer> list = new ArrayList<>();
-    int lowLength = String.valueOf(low).length();
-    int highLength = String.valueOf(high).length();
-    for (int length = lowLength; length < highLength + 1; length++) {
-      for (int start = 0; start < n - length; start++) {
-        int num = Integer.parseInt(bucket.substring(start, start + length));
+    List<Integer> result = new ArrayList<>();
+    int minLength = String.valueOf(low).length();
+    int maxLength = String.valueOf(high).length();
+    for (int currLength = minLength; currLength <= maxLength; currLength++) {
+      for (int idx = 0; idx < n - currLength; idx++) {
+        int num = Integer.parseInt(bucket.substring(idx, idx + currLength));
         if (num >= low && num <= high) {
-          list.add(num);
+          result.add(num);
         }
       }
     }
-    return list;
+    return result;
   }
 }

From e7f7a44d511086946f5e2cabf5f02c9814971df5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 Jan 2022 14:47:36 -0800
Subject: [PATCH 0709/2175] Create Find All Lonely Numbers in the Array.java

---
 Medium/Find All Lonely Numbers in the Array.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Find All Lonely Numbers in the Array.java

diff --git a/Medium/Find All Lonely Numbers in the Array.java b/Medium/Find All Lonely Numbers in the Array.java
new file mode 100644
index 00000000..c55981d5
--- /dev/null
+++ b/Medium/Find All Lonely Numbers in the Array.java	
@@ -0,0 +1,16 @@
+import java.util.Map.Entry;
+
+
+class Solution {
+  public List<Integer> findLonely(int[] nums) {
+    Map<Integer, Long> map = Arrays.stream(nums)
+        .boxed()
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
+    return map.entrySet().stream()
+        .filter(
+            entry -> entry.getValue().equals(1L) && !map.containsKey(entry.getKey() + 1)
+            && !map.containsKey(entry.getKey() - 1))
+        .map(Entry::getKey)
+        .collect(Collectors.toList());
+  }
+}

From bff7d99d9b2538f0d3bfd67ad4dcaff825481f5b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 Jan 2022 14:55:39 -0800
Subject: [PATCH 0710/2175] Update Grumpy Bookstore Owner.java

---
 Medium/Grumpy Bookstore Owner.java | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/Medium/Grumpy Bookstore Owner.java b/Medium/Grumpy Bookstore Owner.java
index ac064c2a..996ac4d0 100644
--- a/Medium/Grumpy Bookstore Owner.java	
+++ b/Medium/Grumpy Bookstore Owner.java	
@@ -1,19 +1,16 @@
 class Solution {
-    public int maxSatisfied(int[] customers, int[] grumpy, int X) {
-        int totalSum = 0;
-        int maxDiff = 0;
-        int grumpySum = 0;
-        
-        for (int i = 0; i < customers.length; i++) {
-            totalSum += grumpy[i] == 1 ? 0 : customers[i];
-            grumpySum += grumpy[i] == 1 ? customers[i] : 0;
-            if (i >= X) {
-                grumpySum -= grumpy[i - X] == 1 ? customers[i - X] : 0;
-            }
-            
-            maxDiff = Math.max(maxDiff, grumpySum);
-        }
-
-        return totalSum + maxDiff;
+  public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
+    int totalSum = 0;
+    int maxDiff = 0;
+    int grumpySum = 0;
+    for (int i = 0; i < customers.length; i++) {
+      totalSum += grumpy[i] == 1 ? 0 : customers[i];
+      grumpySum += grumpy[i] == 1 ? customers[i] : 0;
+      if (i >= minutes) {
+        grumpySum -= grumpy[i - minutes] == 1 ? customers[i - minutes] : 0;
+      }
+      maxDiff = Math.max(maxDiff, grumpySum);
     }
+    return totalSum + maxDiff;
+  }
 }

From 265f1bb376f65174f2406b1926089914b4f69472 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 Jan 2022 14:56:08 -0800
Subject: [PATCH 0711/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b84b9c6d..c09eb6d8 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 900+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1000+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count

From 0907e6d516cc8a7ba6a6a3c30fff7756fbbe9a6a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 Jan 2022 17:12:58 -0800
Subject: [PATCH 0712/2175] Update Detect Capital.java

---
 Easy/Detect Capital.java | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/Easy/Detect Capital.java b/Easy/Detect Capital.java
index dafc6211..b27943e7 100644
--- a/Easy/Detect Capital.java	
+++ b/Easy/Detect Capital.java	
@@ -1,25 +1,21 @@
 class Solution {
   public boolean detectCapitalUse(String word) {
-    int n = word.length();
-    if (n == 0) {
-      return true;
-    }
-    boolean firstCaps = Character.isUpperCase(word.charAt(0));
-    for (int i = 1; i < n; i++) {
-      if (firstCaps) {
-        if (Character.isUpperCase(word.charAt(1)) && !Character.isUpperCase(word.charAt(i))) {
+    boolean firstCapital = Character.isUpperCase(word.charAt(0));
+    for (int i = 1; i < word.length(); i++) {
+      if (Character.isUpperCase(word.charAt(i))) {
+        if (!firstCapital || !firstTwoCharactersCapital(word)) {
           return false;
         }
-        if (!Character.isUpperCase(word.charAt(1)) && Character.isUpperCase(word.charAt(i))) {
-          return false;
-        }
-      }
-      else {
-        if (Character.isUpperCase(word.charAt(i))) {
+      } else {
+        if (i > 1 && firstTwoCharactersCapital(word)) {
           return false;
         }
       }
     }
     return true;
   }
+  
+  private boolean firstTwoCharactersCapital(String word) {
+    return Character.isUpperCase(word.charAt(0)) && Character.isUpperCase(word.charAt(1));
+  }
 }

From 128872dd88c8138a720fd3b9e95c5eaffc62228d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 24 Jan 2022 08:08:20 -0800
Subject: [PATCH 0713/2175] Update Moving Average from Data Stream.java

---
 Easy/Moving Average from Data Stream.java | 24 +++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Easy/Moving Average from Data Stream.java b/Easy/Moving Average from Data Stream.java
index 1c218cfb..e52fa84a 100644
--- a/Easy/Moving Average from Data Stream.java	
+++ b/Easy/Moving Average from Data Stream.java	
@@ -1,22 +1,22 @@
 class MovingAverage {
-
-  /** Initialize your data structure here. */
-  Queue<Integer> queue;
-  int size;
-  double sum;
+  
+  private int currSum;
+  private Queue<Integer> queue;
+  private int size;
+  
   public MovingAverage(int size) {
-    sum = 0;
+    this.currSum = 0;
     this.size = size;
-    queue = new LinkedList<>();
+    this.queue = new LinkedList<>();
   }
 
   public double next(int val) {
-    queue.add(val);
-    sum += val;
-    if (queue.size() > size) {
-      sum -= queue.remove();
+    this.queue.add(val);
+    this.currSum += val;
+    if (this.queue.size() > this.size) {
+      this.currSum -= this.queue.remove();
     }
-    return sum / queue.size();
+    return ((double) this.currSum) / this.queue.size();
   }
 }
 

From 0d7e41dd8a39648a5da13ad8ab35882f7f9bee10 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 24 Jan 2022 08:28:03 -0800
Subject: [PATCH 0714/2175] Update Design File System.java

---
 Medium/Design File System.java | 64 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 35 deletions(-)

diff --git a/Medium/Design File System.java b/Medium/Design File System.java
index 91a8dccb..aef4ab97 100644
--- a/Medium/Design File System.java	
+++ b/Medium/Design File System.java	
@@ -1,57 +1,51 @@
 class FileSystem {
-  FileNode root;
+
+  private FileNode root;
+
   public FileSystem() {
-    root = new FileNode("-");
+    this.root = new FileNode();
   }
 
   public boolean createPath(String path, int value) {
-    FileNode curr = root;
-    String[] directories = path.split("/");
-    for (int i = 0; i < directories.length; i++) {
-      if (directories[i].equals("")) {
-        continue;
+    String[] split = path.split("/");
+    FileNode node = root;
+    for (int i = 1; i < split.length - 1; i++) {
+      if (!node.children.containsKey(split[i])) {
+        return false;
       }
-      if (!curr.children.containsKey(directories[i])) {
-        if (i != directories.length - 1) {
-          return false;
-        }
-        curr.children.put(directories[i], new FileNode(directories[i]));
-      }
-      curr = curr.children.get(directories[i]);
+      node = node.children.get(split[i]);
     }
-    if (curr.val != -1) {
+    if (node.children.containsKey(split[split.length - 1])) {
       return false;
     }
-    curr.val = value;
+    node.children.put(split[split.length - 1], new FileNode(value));
     return true;
   }
 
   public int get(String path) {
-    FileNode curr = root;
-    String[] directories = path.split("/");
-    for (int i = 0; i < directories.length; i++) {
-      if (directories[i].equals("")) {
-        continue;
-      }
-      if (!curr.children.containsKey(directories[i])) {
+    String[] split = path.split("/");
+    FileNode node = root;
+    for (int i = 1; i < split.length; i++) {
+      if (!node.children.containsKey(split[i])) {
         return -1;
       }
-      curr = curr.children.get(directories[i]);
+      node = node.children.get(split[i]);
     }
-    return curr.val;
+    return node.value == null ? -1 : node.value;
   }
-}
 
+  private static class FileNode {
+    private final Map<String, FileNode> children;
+    private Integer value;
+
+    public FileNode() {
+      this.children = new HashMap<>();
+    }
 
-class FileNode {
-  String fileName;
-  int val;
-  Map<String, FileNode> children;
-  
-  public FileNode(String fileName) {
-    this.fileName = fileName;
-    val = -1;
-    children = new HashMap<>();
+    public FileNode(Integer value) {
+      this.children = new HashMap<>();
+      this.value = value;
+    }
   }
 }
 

From 05b79f265b0a697fbb7ef36415416695c985cf3e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 24 Jan 2022 14:27:24 -0800
Subject: [PATCH 0715/2175] Update Print Immutable Linked List in Reverse.java

---
 Medium/Print Immutable Linked List in Reverse.java | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/Medium/Print Immutable Linked List in Reverse.java b/Medium/Print Immutable Linked List in Reverse.java
index 0ec55d3e..d571d18e 100644
--- a/Medium/Print Immutable Linked List in Reverse.java	
+++ b/Medium/Print Immutable Linked List in Reverse.java	
@@ -9,10 +9,13 @@
 
 class Solution {
   public void printLinkedListInReverse(ImmutableListNode head) {
-    if (head == null) {
-      return;
+    Stack<ImmutableListNode> stack = new Stack<>();
+    while (head != null) {
+      stack.push(head);
+      head = head.getNext();
+    }
+    while (!stack.isEmpty()) {
+      stack.pop().printValue();
     }
-    printLinkedListInReverse(head.getNext());
-    head.printValue();
   }
 }

From 8ead5785a413718cb6c633e12e27c520112696d6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 25 Jan 2022 06:25:20 -0800
Subject: [PATCH 0716/2175] Update and rename Medium/Missing Ranges.java to
 Easy/Missing Ranges.java

---
 Easy/Missing Ranges.java   | 24 ++++++++++++++++++++++++
 Medium/Missing Ranges.java | 25 -------------------------
 2 files changed, 24 insertions(+), 25 deletions(-)
 create mode 100644 Easy/Missing Ranges.java
 delete mode 100644 Medium/Missing Ranges.java

diff --git a/Easy/Missing Ranges.java b/Easy/Missing Ranges.java
new file mode 100644
index 00000000..16581dcb
--- /dev/null
+++ b/Easy/Missing Ranges.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public List<String> findMissingRanges(int[] nums, int lower, int upper) {
+    List<String> ranges = new ArrayList<>();
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] < lower) {
+        continue;
+      }
+      if (nums[i] == lower) {
+        lower++;
+        continue;
+      }
+      ranges.add(getRange(lower, ( nums[i] - 1)));
+      lower = nums[i] + 1;
+    }
+    if (lower <= upper) {
+      ranges.add(getRange(lower, upper));
+    }
+    return ranges;
+  }
+  
+  private String getRange(int down, int up) {
+    return down == up ? String.valueOf(up) : down + "->" + up;
+  }
+}
diff --git a/Medium/Missing Ranges.java b/Medium/Missing Ranges.java
deleted file mode 100644
index 66d05e39..00000000
--- a/Medium/Missing Ranges.java	
+++ /dev/null
@@ -1,25 +0,0 @@
-class Solution {
-  public List<String> findMissingRanges(int[] nums, int lower, int upper) {
-    List<String> ranges = new ArrayList<>();
-    long currLower = (long) lower;
-    for (int i = 0; i < nums.length; i++) {
-      if (nums[i] < currLower) {
-        continue;
-      }
-      if (nums[i] == currLower) {
-        currLower++;
-        continue;
-      }
-      ranges.add(getRange(currLower, ((long) nums[i] - 1)));
-      currLower = ((long) nums[i]) + 1;
-    }
-    if (currLower <= upper) {
-      ranges.add(getRange(currLower, (long) upper));
-    }
-    return ranges;
-  }
-  
-  private String getRange(long down, long up) {
-    return down == up ? String.valueOf(up) : down + "->" + up;
-  }
-}

From 360d353dddb5be4d449ed2f5c358ae03f409cce9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 25 Jan 2022 14:05:21 -0800
Subject: [PATCH 0717/2175] Update Shortest Word Distance.java

---
 Easy/Shortest Word Distance.java | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/Easy/Shortest Word Distance.java b/Easy/Shortest Word Distance.java
index 24945f35..9faeb49e 100644
--- a/Easy/Shortest Word Distance.java	
+++ b/Easy/Shortest Word Distance.java	
@@ -1,17 +1,16 @@
 class Solution {
-  public int shortestDistance(String[] words, String word1, String word2) {
-    int idx1 = -1;
-    int idx2 = -1;
-    int minDistance = words.length;
-    for (int i = 0; i < words.length; i++) {
-      if (words[i].equals(word1)) {
-        idx1 = i;
+  public int shortestDistance(String[] wordsDict, String word1, String word2) {
+    int idxOne = -1;
+    int idxTwo = -1;
+    int minDistance = Integer.MAX_VALUE;
+    for (int i = 0; i < wordsDict.length; i++) {
+      if (wordsDict[i].equals(word1)) {
+        idxOne = i;
+      } else if (wordsDict[i].equals(word2)) {
+        idxTwo = i;
       }
-      else if (words[i].equals(word2)) {
-        idx2 = i;
-      }
-      if (idx1 != -1 && idx2 != -1) {
-        minDistance = Math.min(minDistance, Math.abs(idx1 - idx2));
+      if (idxOne != -1 && idxTwo != -1) {
+        minDistance = Math.min(minDistance, Math.abs(idxOne - idxTwo));
       }
     }
     return minDistance;

From dfc6ba6402e84dd98402466713bec67aca07dd79 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 25 Jan 2022 14:23:03 -0800
Subject: [PATCH 0718/2175] Update and rename Valid Word Abbrevation.java to
 Valid Word Abbreviation.java

---
 Easy/Valid Word Abbrevation.java  | 26 --------------------------
 Easy/Valid Word Abbreviation.java | 28 ++++++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 26 deletions(-)
 delete mode 100644 Easy/Valid Word Abbrevation.java
 create mode 100644 Easy/Valid Word Abbreviation.java

diff --git a/Easy/Valid Word Abbrevation.java b/Easy/Valid Word Abbrevation.java
deleted file mode 100644
index 4299405e..00000000
--- a/Easy/Valid Word Abbrevation.java	
+++ /dev/null
@@ -1,26 +0,0 @@
-class Solution {
-  public boolean validWordAbbreviation(String word, String abbr) {
-    int idx1 = 0;
-    int idx2 = 0;
-    while (idx1 < word.length() && idx2 < abbr.length()) {
-      if (!Character.isDigit(abbr.charAt(idx2))) {
-        if (word.charAt(idx1) != abbr.charAt(idx2)) {
-          return false;
-        }
-        idx1++;
-        idx2++;
-      }
-      else {
-        if (abbr.charAt(idx2) == '0') {
-          return false;
-        }
-        int count = 0;
-        while (idx2 < abbr.length() && Character.isDigit(abbr.charAt(idx2))) {
-          count = count * 10 + Character.getNumericValue(abbr.charAt(idx2++));
-        }
-        idx1 += count;
-      }
-    }
-    return idx1 == word.length() && idx2 == abbr.length();
-  }
-}
diff --git a/Easy/Valid Word Abbreviation.java b/Easy/Valid Word Abbreviation.java
new file mode 100644
index 00000000..688b39fe
--- /dev/null
+++ b/Easy/Valid Word Abbreviation.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public boolean validWordAbbreviation(String word, String abbr) {
+    int wordIdx = 0;
+    int abbrIdx = 0;
+    while (wordIdx < word.length() && abbrIdx < abbr.length()) {
+      if (Character.isDigit(abbr.charAt(abbrIdx))) {
+        if (abbr.charAt(abbrIdx) == '0') {
+          return false;
+        }
+        int count = 0;
+        while (abbrIdx < abbr.length() && Character.isDigit(abbr.charAt(abbrIdx))) {
+          count = count * 10 + Character.getNumericValue(abbr.charAt(abbrIdx++));
+        }
+        wordIdx += count;
+        if (wordIdx > word.length()) {
+          return false;
+        }
+      } else {
+        if (word.charAt(wordIdx) != abbr.charAt(abbrIdx)) {
+          return false;
+        }
+        wordIdx++;
+        abbrIdx++;
+      }
+    }
+    return wordIdx == word.length() && abbrIdx == abbr.length();
+  }
+}

From 5f1e682709d69cd34930b745790d1b7bd3810e11 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 26 Jan 2022 08:24:41 -0800
Subject: [PATCH 0719/2175] Update All Elements in Two Binary Search Trees.java

---
 ...l Elements in Two Binary Search Trees.java | 45 ++++++++++---------
 1 file changed, 24 insertions(+), 21 deletions(-)

diff --git a/Medium/All Elements in Two Binary Search Trees.java b/Medium/All Elements in Two Binary Search Trees.java
index a973fd93..92fc3d9f 100644
--- a/Medium/All Elements in Two Binary Search Trees.java	
+++ b/Medium/All Elements in Two Binary Search Trees.java	
@@ -15,33 +15,36 @@
  */
 class Solution {
   public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
-    Stack<TreeNode> stack1 = new Stack<>();
-    Stack<TreeNode> stack2 = new Stack<>();
-    updateStack(stack1, root1);
-    updateStack(stack2, root2);
+    Stack<TreeNode> stackOne = new Stack<>();
+    Stack<TreeNode> stackTwo = new Stack<>();
+    while (root1 != null) {
+      stackOne.push(root1);
+      root1 = root1.left;
+    }
+    while (root2 != null) {
+      stackTwo.push(root2);
+      root2 = root2.left;
+    }
     List<Integer> list = new ArrayList<>();
-    while (!stack1.isEmpty() || !stack2.isEmpty()) {
-      if (!stack1.isEmpty() && !stack2.isEmpty()) {
-        if (stack1.peek().val < stack2.peek().val) {
-          TreeNode popped = stack1.pop();
+    while (!stackOne.isEmpty() || !stackTwo.isEmpty()) {
+      if (!stackOne.isEmpty() && !stackTwo.isEmpty()) {
+        if (stackOne.peek().val < stackTwo.peek().val) {
+          TreeNode popped = stackOne.pop();
           list.add(popped.val);
-          updateStack(stack1, popped.right);
-        }
-        else {
-          TreeNode popped = stack2.pop();
+          updateStack(stackOne, popped.right);
+        } else {
+          TreeNode popped = stackTwo.pop();
           list.add(popped.val);
-          updateStack(stack2, popped.right);
+          updateStack(stackTwo, popped.right);
         }
-      }
-      else if (!stack1.isEmpty() && stack2.isEmpty()) {
-        TreeNode popped = stack1.pop();
+      } else if (!stackOne.isEmpty() && stackTwo.isEmpty()) {
+        TreeNode popped = stackOne.pop();
         list.add(popped.val);
-        updateStack(stack1, popped.right);
-      }
-      else {
-        TreeNode popped = stack2.pop();
+        updateStack(stackOne, popped.right);
+      } else {
+        TreeNode popped = stackTwo.pop();
         list.add(popped.val);
-        updateStack(stack2, popped.right);
+        updateStack(stackTwo, popped.right);
       }
     }
     return list;

From abcb8622c170b27e2d4bc2eddc389f0e9266c342 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 26 Jan 2022 09:04:26 -0800
Subject: [PATCH 0720/2175] Create Number of Provinces.java

---
 Medium/Number of Provinces.java | 60 +++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 Medium/Number of Provinces.java

diff --git a/Medium/Number of Provinces.java b/Medium/Number of Provinces.java
new file mode 100644
index 00000000..436059e3
--- /dev/null
+++ b/Medium/Number of Provinces.java	
@@ -0,0 +1,60 @@
+class Solution {
+  public int findCircleNum(int[][] isConnected) {
+    int n = isConnected.length;
+    DisjointSet disjointSet = new DisjointSet(n);
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        if (isConnected[i][j] == 1) {
+          disjointSet.union(i, j);
+        }
+      }
+    }
+    Set<Integer> set = new HashSet<>();
+    for (int i = 0; i < n; i++) {
+      set.add(disjointSet.find(i));
+    }
+    return set.size();
+  }
+
+  private static class DisjointSet {
+
+    private final int[] root;
+    private final int[] rank;
+
+    public DisjointSet(int size) {
+      this.root = new int[size];
+      this.rank = new int[size];
+      for (int i = 0; i < size; i++) {
+        this.root[i] = i;
+        this.rank[i] = 1;
+      }
+    }
+
+    public void union(int nodeOne, int nodeTwo) {
+      int rootOne = find(nodeOne);
+      int rootTwo = find(nodeTwo);
+      if (rootOne != rootTwo) {
+        if (this.rank[rootOne] > this.rank[rootTwo]) {
+          this.root[rootTwo] = rootOne;
+        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
+          this.root[rootOne] = rootTwo;
+        } else {
+          this.root[rootTwo] = rootOne;
+          this.rank[rootOne]++;
+        }
+      }
+    }
+
+
+    public int find(int node) {
+      if (node == root[node]) {
+        return node;
+      }
+      return root[node] = find(root[node]);
+    }
+
+    public boolean connected(int nodeOne, int nodeTwo) {
+      return find(nodeOne) == find(nodeTwo);
+    }
+  }
+}

From 732d34432166a8e2721a2c2bbac39c74d01c996e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 26 Jan 2022 12:45:03 -0800
Subject: [PATCH 0721/2175] Update Sentence Similarity.java

---
 Easy/Sentence Similarity.java | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/Easy/Sentence Similarity.java b/Easy/Sentence Similarity.java
index 7e779bfe..38f62e43 100644
--- a/Easy/Sentence Similarity.java	
+++ b/Easy/Sentence Similarity.java	
@@ -1,21 +1,22 @@
 class Solution {
-  public boolean areSentencesSimilar(String[] words1, String[] words2, List<List<String>> pairs) {
-    if (words1.length != words2.length) {
+  public boolean areSentencesSimilar(
+      String[] sentence1, String[] sentence2, List<List<String>> similarPairs) {
+    if (sentence1.length != sentence2.length) {
       return false;
     }
-    Set<String> set = new HashSet<>();
-    for (List<String> pair : pairs) {
-      String word1 = pair.get(0);
-      String word2 = pair.get(1);
-      set.add(word1 + "|" + word2);
+    Map<String, Set<String>> similarWords = new HashMap<>();
+    for (List<String> pair : similarPairs) {
+      similarWords.computeIfAbsent(pair.get(0), k -> new HashSet<>()).add(pair.get(1));
+      similarWords.computeIfAbsent(pair.get(1), k -> new HashSet<>()).add(pair.get(0));
     }
-    for (int i = 0; i < words1.length; i++) {
-      String word1 = words1[i];
-      String word2 = words2[i];
-      if (!(word1.equals(word2) || set.contains(word1 + "|" + word2) || set.contains(word2 + "|" + word1))) {
-        return false;
+    for (int i = 0; i < sentence1.length; i++) {
+      if (sentence1[i].equals(sentence2[i])
+          || similarWords.getOrDefault(sentence1[i], new HashSet<>()).contains(sentence2[i])
+          || similarWords.getOrDefault(sentence2[i], new HashSet<>()).contains(sentence1[1])) {
+        continue;
       }
+      return false;
     }
-    return true;
+    return sentence1.length != sentence2.length;
   }
 }

From 99692dec48c958ec825ffe62d0ad338fa2b5cecd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 26 Jan 2022 16:25:38 -0800
Subject: [PATCH 0722/2175] Update Graph Valid Tree.java

---
 Medium/Graph Valid Tree.java | 35 +++++++++++------------------------
 1 file changed, 11 insertions(+), 24 deletions(-)

diff --git a/Medium/Graph Valid Tree.java b/Medium/Graph Valid Tree.java
index 7b35c66f..1c4aaa48 100644
--- a/Medium/Graph Valid Tree.java	
+++ b/Medium/Graph Valid Tree.java	
@@ -1,32 +1,19 @@
 class Solution {
   public boolean validTree(int n, int[][] edges) {
-    Map<Integer, Set<Integer>> map = new HashMap<>();
+    int[] nums = new int[n];
+    Arrays.fill(nums, -1);
     for (int[] edge : edges) {
-      map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
-      map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    int[] visited = new int[n];
-    queue.add(0);
-    visited[0] = 1;
-    while (!queue.isEmpty()) {
-      Integer removed = queue.remove();
-      for (Integer connection : map.getOrDefault(removed, new HashSet<>())) {
-        if (visited[connection] == 1) {
-          return false;
-        }
-        if (visited[connection] == 0) {
-          visited[connection] = 1;
-          queue.add(connection);
-        }
-      }
-      visited[removed] = 2;
-    }
-    for (int node : visited) {
-      if (node == 0) {
+      int rootOne = find(nums, edge[0]);
+      int rootTwo = find(nums, edge[1]);
+      if (rootOne == rootTwo) {
         return false;
       }
+      nums[rootOne] = rootTwo;
     }
-    return true;
+    return edges.length == n - 1;
+  }
+  
+  private int find(int[] nums, int n) {
+    return nums[n] == -1 ? n : find(nums, nums[n]);
   }
 }

From bb137e4bc12263405b21d1c3457cacca666d5869 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 26 Jan 2022 16:38:29 -0800
Subject: [PATCH 0723/2175] Update Number of Connected Components in an
 Undirected Graph.java

---
 ...ted Components in an Undirected Graph.java | 84 +++++++++++--------
 1 file changed, 47 insertions(+), 37 deletions(-)

diff --git a/Medium/Number of Connected Components in an Undirected Graph.java b/Medium/Number of Connected Components in an Undirected Graph.java
index 2c81b9ee..e794deea 100644
--- a/Medium/Number of Connected Components in an Undirected Graph.java	
+++ b/Medium/Number of Connected Components in an Undirected Graph.java	
@@ -1,41 +1,51 @@
 class Solution {
-    public int countComponents(int n, int[][] edges) {
-        Map<Integer, List<Integer>> map = new HashMap<>();
-        
-        for (int[] edge : edges) {
-            map.computeIfAbsent(edge[0], k -> new ArrayList<Integer>()).add(edge[1]);
-            map.computeIfAbsent(edge[1], k -> new ArrayList<Integer>()).add(edge[0]);
-        }
-        
-        Set<Integer> set = new HashSet<>();
-        int count = 0;
-        
-        for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
-            if (set.contains(entry.getKey())) {
-                continue;
-            }
-            
-            Queue<Integer> queue = new LinkedList<>();
-            queue.add(entry.getKey());
-            set.add(entry.getKey());
-            
-            while (!queue.isEmpty()) {
-                int popped = queue.remove();
-                List<Integer> connections = map.getOrDefault(popped, new ArrayList<Integer>());
-                
-                for (int connection : connections) {
-                    if (set.contains(connection)) {
-                        continue;
-                    }
-                    
-                    set.add(connection);
-                    queue.add(connection);
-                }
-            }
-            
-            count++;
+  public int countComponents(int n, int[][] edges) {
+    DisjointSet disjointSet = new DisjointSet(n);
+    for (int[] edge : edges) {
+      disjointSet.union(edge[0], edge[1]);
+    }
+    Set<Integer> rootSet = new HashSet<>();
+    for (int i = 0; i < n; i++) {
+      rootSet.add(disjointSet.find(i));
+    }
+    return rootSet.size();
+  }
+
+  private static class DisjointSet {
+
+    private final int[] root;
+    private final int[] rank;
+
+    public DisjointSet(int size) {
+      this.root = new int[size];
+      this.rank = new int[size];
+      for (int i = 0; i < size; i++) {
+        this.root[i] = i;
+        this.rank[i] = 1;
+      }
+    }
+
+    public void union(int nodeOne, int nodeTwo) {
+      int rootOne = find(nodeOne);
+      int rootTwo = find(nodeTwo);
+      if (rootOne != rootTwo) {
+        if (this.rank[rootOne] > this.rank[rootTwo]) {
+          this.root[rootTwo] = rootOne;
+        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
+          this.root[rootOne] = rootTwo;
+        } else {
+          this.root[rootTwo] = rootOne;
+          this.rank[rootOne]++;
         }
-        
-        return count + (n - set.size());
+      }
+    }
+
+
+    public int find(int node) {
+      if (node == root[node]) {
+        return node;
+      }
+      return root[node] = find(root[node]);
     }
+  }
 }

From ef7dabe5ffeb6885789a1146c3231679a279a855 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 27 Jan 2022 08:46:04 -0800
Subject: [PATCH 0724/2175] Update The Earliest Moment When Everyone Become
 Friends.java

---
 ...t Moment When Everyone Become Friends.java | 86 ++++++++++---------
 1 file changed, 46 insertions(+), 40 deletions(-)

diff --git a/Medium/The Earliest Moment When Everyone Become Friends.java b/Medium/The Earliest Moment When Everyone Become Friends.java
index 739711d6..578a04cb 100644
--- a/Medium/The Earliest Moment When Everyone Become Friends.java	
+++ b/Medium/The Earliest Moment When Everyone Become Friends.java	
@@ -1,48 +1,54 @@
 class Solution {
-    public int earliestAcq(int[][] logs, int N) {
-        Arrays.sort(logs, Comparator.comparingInt(o -> o[0]));
-        Map<Integer, Set<Integer>> map = new HashMap<>();
-
-        for (int[] log : logs) {
-            boolean[] allDone = {false};
-            map.computeIfAbsent(log[1], k -> new HashSet<>()).add(log[2]);
-            dfs(map, log[1], log[2], allDone, N);
-
-            map.computeIfAbsent(log[2], k -> new HashSet<>()).add(log[1]);
-            dfs(map, log[2], log[1], allDone, N);
-
+  public int earliestAcq(int[][] logs, int n) {
+    Arrays.sort(logs, Comparator.comparingInt(o -> o[0]));
+    DisjointSet disjointSet = new DisjointSet(n);
+    for (int[] log : logs) {
+      disjointSet.union(log[1], log[2]);
+      if (disjointSet.unionCount == 1) {
+        return log[0];
+      }
+    }
+    return -1;
+  }
+
+  private static final class DisjointSet {
+
+    private final int[] root;
+    private final int[] rank;
+    public int unionCount;
+
+    public DisjointSet(int size) {
+      this.root = new int[size];
+      this.rank = new int[size];
+      for (int i = 0; i < size; i++) {
+        this.root[i] = i;
+        this.rank[i] = 1;
+      }
+      this.unionCount = size;
+    }
 
-            if (allDone[0]) {
-                return log[0];
-            }
+    public void union(int nodeOne, int nodeTwo) {
+      int rootOne = find(nodeOne);
+      int rootTwo = find(nodeTwo);
+      if (rootOne != rootTwo) {
+        if (this.rank[rootOne] > this.rank[rootTwo]) {
+          this.root[rootTwo] = rootOne;
+        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
+          this.root[rootOne] = rootTwo;
+        } else {
+          this.root[rootTwo] = rootOne;
+          this.rank[rootOne]++;
         }
-
-        return -1;
+        this.unionCount--;
+      }
     }
 
-    private void dfs(Map<Integer, Set<Integer>> map, int f1, int f2, boolean[] allDone, int N) {
-        Set<Integer> visited = new HashSet<>();
-        Queue<Integer> queue = new LinkedList<>();
-        queue.add(f1);
-        visited.add(f1);
-
-        while (!queue.isEmpty()) {
-            int removed = queue.poll();
-            Iterator<Integer> iterator = map.getOrDefault(removed, new HashSet<>()).iterator();
-            while (iterator.hasNext()) {
-                int friend = iterator.next();
-                if (!visited.contains(friend)) {
-                    queue.add(friend);
-                    map.computeIfAbsent(friend, k -> new HashSet<>()).add(f2);
-                    map.computeIfAbsent(f2, k -> new HashSet<>()).add(friend);
 
-                    if (map.get(f2).size() == N || map.get(friend).size() == N) {
-                        allDone[0] = true;
-                    }
-
-                    visited.add(friend);
-                }
-            }
-        }
+    public int find(int node) {
+      if (node == root[node]) {
+        return node;
+      }
+      return root[node] = find(root[node]);
     }
+  }
 }

From 7e583357d930794db2fb138f3ea2d586c438732d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 27 Jan 2022 09:41:02 -0800
Subject: [PATCH 0725/2175] Update Find Anagram Mappings.java

---
 Easy/Find Anagram Mappings.java | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/Easy/Find Anagram Mappings.java b/Easy/Find Anagram Mappings.java
index 74ab5769..2a7c34e3 100644
--- a/Easy/Find Anagram Mappings.java	
+++ b/Easy/Find Anagram Mappings.java	
@@ -1,13 +1,12 @@
 class Solution {
-    public int[] anagramMappings(int[] A, int[] B) {
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int i = 0; i < B.length; i++) {
-            map.put(B[i], i);
-        }
-        int[] ans = new int[A.length];
-        for (int i = 0; i < A.length; i++) {
-            ans[i] = map.get(A[i]);
-        }
-        return ans;
+  public int[] anagramMappings(int[] nums1, int[] nums2) {
+    Map<Integer, Integer> indexMapping = new HashMap<>();
+    for (int i = 0; i < nums2.length; i++) {
+      indexMapping.put(nums2[i], i);
     }
+    for (int i = 0; i < nums1.length; i++) {
+      nums1[i] = indexMapping.get(nums1[i]);
+    }
+    return nums1;
+  }
 }

From 55fe8a831c13379b5a2e83c2cb3eaf5ca93c26b6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 27 Jan 2022 09:49:08 -0800
Subject: [PATCH 0726/2175] Update Remove Vowels from a String.java

---
 Easy/Remove Vowels from a String.java | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/Easy/Remove Vowels from a String.java b/Easy/Remove Vowels from a String.java
index f389ac47..d5c24c1b 100644
--- a/Easy/Remove Vowels from a String.java	
+++ b/Easy/Remove Vowels from a String.java	
@@ -1,14 +1,11 @@
 class Solution {
-    public String removeVowels(String S) {
-        StringBuilder sb = new StringBuilder();
-        Set<Character> set = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u'));
-        
-        for (char c : S.toCharArray()) {
-            if (!set.contains(c)) {
-                sb.append(c);
-            }
-        }
-        
-        return sb.toString();
-    }
+  public String removeVowels(String s) {
+    return s.chars()
+        .mapToObj(c -> (char) c)
+        .filter(c -> "aeiou".indexOf(c) == -1)
+        .collect(Collector.of(StringBuilder::new,
+            StringBuilder::append,
+            StringBuilder::append,
+            StringBuilder::toString));
+  }
 }

From 4ae59e7231059ad63bbfa241f75bd13c233546ef Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 27 Jan 2022 11:04:51 -0800
Subject: [PATCH 0727/2175] Update Minimum Remove to Make Valid
 Parentheses.java

---
 ...imum Remove to Make Valid Parentheses.java | 32 +++++++++----------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/Medium/Minimum Remove to Make Valid Parentheses.java b/Medium/Minimum Remove to Make Valid Parentheses.java
index bc1739e4..45734d11 100644
--- a/Medium/Minimum Remove to Make Valid Parentheses.java	
+++ b/Medium/Minimum Remove to Make Valid Parentheses.java	
@@ -1,27 +1,25 @@
 class Solution {
   public String minRemoveToMakeValid(String s) {
     Stack<Integer> stack = new Stack<>();
-    char[] chars = s.toCharArray();
-    for (int i = 0; i < chars.length; i++) {
-      if (chars[i] == '(') {
-        stack.push(i);
-      }
-      else if (chars[i] == ')') {
-        if (stack.isEmpty()) {
-          chars[i] = '-';
-        }
-        else {
-          stack.pop();
+    Set<Integer> validIndexes = new HashSet<>();
+    for (int i = 0; i < s.length(); i++) {
+      if (s.charAt(i) == '(') {
+        stack.add(i);
+      } else if (s.charAt(i) == ')') {
+        if (!stack.isEmpty()) {
+          validIndexes.add(stack.pop());
+          validIndexes.add(i);
         }
       }
     }
-    while (!stack.isEmpty()) {
-      chars[stack.pop()] = '-';
-    }
     StringBuilder sb = new StringBuilder();
-    for (int i = 0; i < chars.length; i++) {
-      if (chars[i] != '-') {
-        sb.append(chars[i]);
+    for (int i = 0; i < s.length(); i++) {
+      if (s.charAt(i) == '(' || s.charAt(i) == ')') {
+        if (validIndexes.contains(i)) {
+          sb.append(s.charAt(i));
+        }
+      } else {
+        sb.append(s.charAt(i));
       }
     }
     return sb.toString();

From 8ac764a83e264891c5baf136c55032b69c6c9440 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 27 Jan 2022 16:21:19 -0800
Subject: [PATCH 0728/2175] Update and rename Add and Search Word - Data
 structure design.java to Design Add and Search Words Data Structure.java

---
 ...d Search Word - Data structure design.java | 68 -------------------
 ...n Add and Search Words Data Structure.java | 59 ++++++++++++++++
 2 files changed, 59 insertions(+), 68 deletions(-)
 delete mode 100644 Medium/Add and Search Word - Data structure design.java
 create mode 100644 Medium/Design Add and Search Words Data Structure.java

diff --git a/Medium/Add and Search Word - Data structure design.java b/Medium/Add and Search Word - Data structure design.java
deleted file mode 100644
index 2d73cc43..00000000
--- a/Medium/Add and Search Word - Data structure design.java	
+++ /dev/null
@@ -1,68 +0,0 @@
-class WordDictionary {
-
-  /** Initialize your data structure here. */
-  Node root;
-  public WordDictionary() {
-    root = new Node('-');
-  }
-
-  /** Adds a word into the data structure. */
-  public void addWord(String word) {
-    Node curr = root;
-    for (char c : word.toCharArray()) {
-      if (curr.children[c - 'a'] == null) {
-        curr.children[c - 'a'] = new Node(c);
-      }
-      curr = curr.children[c - 'a'];
-    }
-    curr.isWord = true;
-  }
-
-  /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
-  public boolean search(String word) {
-    Node curr = root;
-    return searchHelper(curr, word, 0);
-  }
-  
-  private boolean searchHelper(Node curr, String word, int idx) {
-    if (idx == word.length()) {
-      return curr.isWord;
-    }
-    char c = word.charAt(idx);
-    if (c != '.') {
-      if (curr.children[c - 'a'] == null) {
-        return false;
-      }
-      return searchHelper(curr.children[c - 'a'], word, idx + 1);
-    }
-    else {
-      boolean flag = false;
-      for (Node child : curr.children) {
-        if (child != null) {
-          flag = flag | searchHelper(child, word, idx + 1);
-        }
-      }
-      return flag;
-    }
-  }
-}
-
-
-class Node {
-  char c;
-  Node[] children;
-  boolean isWord;
-  
-  public Node(char c) {
-    this.c = c;
-    children = new Node[26];
-    isWord = false;
-  }
-}
-
-/**
- * Your WordDictionary object will be instantiated and called as such:
- * WordDictionary obj = new WordDictionary();
- * obj.addWord(word);
- * boolean param_2 = obj.search(word);
- */
diff --git a/Medium/Design Add and Search Words Data Structure.java b/Medium/Design Add and Search Words Data Structure.java
new file mode 100644
index 00000000..0f87fece
--- /dev/null
+++ b/Medium/Design Add and Search Words Data Structure.java	
@@ -0,0 +1,59 @@
+class WordDictionary {
+
+  private final TrieNode root;
+
+  public WordDictionary() {
+    this.root = new TrieNode();
+  }
+
+  public void addWord(String word) {
+    TrieNode curr = root;
+    for (char c : word.toCharArray()) {
+      if (!curr.children.containsKey(c)) {
+        curr.children.put(c, new TrieNode());
+      }
+      curr = curr.children.get(c);
+    }
+    curr.isWord = true;
+  }
+
+  public boolean search(String word) {
+    return searchHelper(word, 0, root);
+  }
+
+  private boolean searchHelper(String word, int idx, TrieNode curr) {
+    if (idx == word.length()) {
+      return curr.isWord;
+    }
+    if (curr.children.containsKey(word.charAt(idx))) {
+      return searchHelper(word, idx + 1, curr.children.get(word.charAt(idx)));
+    }
+    if (word.charAt(idx) == '.') {
+      for (char c : curr.children.keySet()) {
+        if (searchHelper(word, idx + 1, curr.children.get(c))) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+
+  private static class TrieNode {
+
+    private final Map<Character, TrieNode> children;
+    private boolean isWord;
+
+    public TrieNode() {
+      this.children = new HashMap<>();
+      this.isWord = false;
+    }
+  }
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary obj = new WordDictionary();
+ * obj.addWord(word);
+ * boolean param_2 = obj.search(word);
+ */

From 5e1c7d748db6725a44783018312c3eccb02d1b8b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 28 Jan 2022 09:21:15 -0800
Subject: [PATCH 0729/2175] Update Valid Palindrome II.java

---
 Easy/Valid Palindrome II.java | 32 +++++++++++++-------------------
 1 file changed, 13 insertions(+), 19 deletions(-)

diff --git a/Easy/Valid Palindrome II.java b/Easy/Valid Palindrome II.java
index f525f8ce..c0edfc4c 100644
--- a/Easy/Valid Palindrome II.java	
+++ b/Easy/Valid Palindrome II.java	
@@ -1,27 +1,21 @@
 class Solution {
   public boolean validPalindrome(String s) {
-    int start = 0;
-    int end = s.length() - 1;
-    while (start < end && s.charAt(start) == s.charAt(end)) {
-      start++;
-      end--;
-    }
-    if (start >= end) {
-      return true;
-    }
-    if (isPalindrome(s.substring(start + 1, end + 1)) || isPalindrome(s.substring(start, end))) {
+    int[] firstPalindromeCheck = isPalindromHelper(s);
+    if (firstPalindromeCheck[0] == -1) {
       return true;
     }
-    return false;
+    int[] skipLeft = isPalindromHelper(s.substring(firstPalindromeCheck[0] + 1, firstPalindromeCheck[1] + 1));
+    int[] skipRight = isPalindromHelper(s.substring(firstPalindromeCheck[0], check[1]));
+    return skipLeft[0] == -1 || skipRight[0] == -1;
   }
-  
-  private boolean isPalindrome(String s) {
-    int start = 0;
-    int end = s.length() - 1;
-    while (start < end && s.charAt(start) == s.charAt(end)) {
-      start++;
-      end--;
+
+  private int[] isPalindromHelper(String s) {
+    int startIdx = 0;
+    int endIdx = s.length() - 1;
+    while (startIdx < endIdx && s.charAt(startIdx) == s.charAt(endIdx)) {
+      startIdx++;
+      endIdx--;
     }
-    return start >= end;
+    return startIdx >= endIdx ? new int[]{-1} : new int[]{startIdx, endIdx};
   }
 }

From 4b18140aaf851557c95e033a911d82cddc7eb122 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 28 Jan 2022 12:23:22 -0800
Subject: [PATCH 0730/2175] Create Smallest String With Swaps.java

---
 Medium/Smallest String With Swaps.java | 60 ++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 Medium/Smallest String With Swaps.java

diff --git a/Medium/Smallest String With Swaps.java b/Medium/Smallest String With Swaps.java
new file mode 100644
index 00000000..e9cea772
--- /dev/null
+++ b/Medium/Smallest String With Swaps.java	
@@ -0,0 +1,60 @@
+class Solution {
+  public String smallestStringWithSwaps(String s, List<List<Integer>> pairs) {
+    int n = s.length();
+    DisjointSet disjointSet = new DisjointSet(n);
+    for (List<Integer> pair : pairs) {
+      disjointSet.union(pair.get(0), pair.get(1));
+    }
+    Map<Integer, PriorityQueue<Character>> map = new HashMap<>();
+    for (int i = 0; i < n; i++) {
+      int root = disjointSet.find(i);
+      map.computeIfAbsent(root, k -> new PriorityQueue<>()).offer(s.charAt(i));
+    }
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < s.length(); i++) {
+      sb.append(map.get(disjointSet.find(i)).poll());
+    }
+    return sb.toString();
+  }
+
+  private static final class DisjointSet {
+
+    private final int[] root;
+    private final int[] rank;
+    public int unionCount;
+
+    public DisjointSet(int size) {
+      this.root = new int[size];
+      this.rank = new int[size];
+      for (int i = 0; i < size; i++) {
+        this.root[i] = i;
+        this.rank[i] = 1;
+      }
+      this.unionCount = size;
+    }
+
+    public void union(int nodeOne, int nodeTwo) {
+      int rootOne = find(nodeOne);
+      int rootTwo = find(nodeTwo);
+      if (rootOne != rootTwo) {
+        if (this.rank[rootOne] > this.rank[rootTwo]) {
+          this.root[rootTwo] = rootOne;
+        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
+          this.root[rootOne] = rootTwo;
+        } else {
+          this.root[rootTwo] = rootOne;
+          this.rank[rootOne]++;
+        }
+        this.unionCount--;
+      }
+    }
+
+
+    public int find(int node) {
+      if (node == root[node]) {
+        return node;
+      }
+      return root[node] = find(root[node]);
+    }
+  }
+}

From 66dd846b8cebe6bd46570a4b321e572da30ad601 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 29 Jan 2022 07:57:16 -0800
Subject: [PATCH 0731/2175] Create Buildings With an Ocean View.java

---
 Medium/Buildings With an Ocean View.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Buildings With an Ocean View.java

diff --git a/Medium/Buildings With an Ocean View.java b/Medium/Buildings With an Ocean View.java
new file mode 100644
index 00000000..b9735daa
--- /dev/null
+++ b/Medium/Buildings With an Ocean View.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int[] findBuildings(int[] heights) {
+    List<Integer> oceanViewBuildings = new ArrayList<>();
+    int maxHeight = 0;
+    for (int i = heights.length - 1; i >= 0; i--) {
+      if (heights[i] > maxHeight) {
+        oceanViewBuildings.add(i);
+      }
+      maxHeight = Math.max(maxHeight, heights[i]);
+    }
+    return oceanViewBuildings.stream().sorted().mapToInt(Integer::valueOf).toArray();
+  }
+}

From 9b51132e20c25a44e349c5373cf3b56121186b7b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 29 Jan 2022 08:20:13 -0800
Subject: [PATCH 0732/2175] Update Group Shifted Strings.java

---
 Medium/Group Shifted Strings.java | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/Medium/Group Shifted Strings.java b/Medium/Group Shifted Strings.java
index 2207727c..b1209bbf 100644
--- a/Medium/Group Shifted Strings.java	
+++ b/Medium/Group Shifted Strings.java	
@@ -1,19 +1,17 @@
 class Solution {
   public List<List<String>> groupStrings(String[] strings) {
     Map<String, List<String>> map = new HashMap<>();
-    for (String str : strings) {
-      map.computeIfAbsent(getKey(str), k -> new ArrayList<>()).add(str);
+    for (String s : strings) {
+      map.computeIfAbsent(getShiftedCode(s), k -> new ArrayList<>()).add(s);
     }
     return new ArrayList<>(map.values());
   }
-  
-  private String getKey(String s) {
-    StringBuilder sb = new StringBuilder();
+
+  private String getShiftedCode(String s) {
+    StringBuilder key = new StringBuilder();
     for (int i = 1; i < s.length(); i++) {
-      int diff = s.charAt(i) - s.charAt(i - 1);
-      diff = diff < 0 ? diff + 26 : diff;
-      sb.append(diff);
+      key.append(String.format("%2d", (s.charAt(i) - s.charAt(i-1) + 26) % 26));
     }
-    return sb.toString();
+    return key.toString();
   }
 }

From 82b507468fa894d9797ca4540b8409517965249b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 29 Jan 2022 14:18:02 -0800
Subject: [PATCH 0733/2175] Update Range Sum of BST.java

---
 Easy/Range Sum of BST.java | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/Easy/Range Sum of BST.java b/Easy/Range Sum of BST.java
index 35b3b6ae..b3d21555 100644
--- a/Easy/Range Sum of BST.java	
+++ b/Easy/Range Sum of BST.java	
@@ -15,23 +15,21 @@
  */
 class Solution {
   public int rangeSumBST(TreeNode root, int low, int high) {
-    int[] rangeSum = {0};
-    helper(root, low, high, rangeSum);
-    return rangeSum[0];
-  }
-  
-  private void helper(TreeNode root, int low, int high, int[] rangeSum) {
-    if (root == null) {
-      return;
-    }
-    if (root.val >= low && root.val <= high) {
-      rangeSum[0] += root.val;
-    }
-    if (root.val >= low) {
-      helper(root.left, low, high, rangeSum);
-    }
-    if (root.val <= high) {
-      helper(root.right, low, high, rangeSum);
+    Stack<TreeNode> stack = new Stack<>();
+    stack.push(root);
+    int sum = 0;
+    while (!stack.isEmpty()) {
+        TreeNode removed = stack.pop();
+        if (removed.val > low && removed.left != null) { 
+          stack.push(removed.left); 
+        } 
+        if (removed.val < high && removed.right != null) { 
+          stack.push(removed.right); 
+        }
+        if (low <= removed.val && removed.val <= high) {
+          sum += removed.val; 
+        }
     }
+    return sum;
   }
 }

From 8a2bac633c3fabf9a2d2baa99ec4d9f9729f2d36 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 29 Jan 2022 18:37:25 -0800
Subject: [PATCH 0734/2175] Update Rotate Array.java

---
 Medium/Rotate Array.java | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/Medium/Rotate Array.java b/Medium/Rotate Array.java
index 4eefa93c..1090cd86 100644
--- a/Medium/Rotate Array.java	
+++ b/Medium/Rotate Array.java	
@@ -1,18 +1,19 @@
 class Solution {
   public void rotate(int[] nums, int k) {
-    k %= nums.length;
-    reverse(nums, 0, nums.length - 1);
-    reverse(nums, 0, k - 1);
-    reverse(nums, k, nums.length - 1);
-  }
-  
-  private void reverse(int[] nums, int start, int end) {
-    while (start < end) {
-      int temp = nums[start];
-      nums[start] = nums[end];
-      nums[end] = temp;
-      start++;
-      end--;
+    int n = nums.length;
+    k %= n;
+    int count = 0;
+    for (int i = 0; count < n; i++) {
+      int currIdx = i;
+      int prevValue = nums[i];
+      do {
+        int nextIdx = (currIdx + k) % n;
+        int tempValue = nums[nextIdx];
+        nums[nextIdx] = prevValue;
+        prevValue = tempValue;
+        currIdx = nextIdx;
+        count++;
+      } while (i != currIdx);
     }
   }
 }

From 725c0458d2e7e1030db7de6fd13f70952f67bfaa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Jan 2022 07:13:47 -0800
Subject: [PATCH 0735/2175] Create Keep Multiplying Found Values by Two.java

---
 Easy/Keep Multiplying Found Values by Two.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Keep Multiplying Found Values by Two.java

diff --git a/Easy/Keep Multiplying Found Values by Two.java b/Easy/Keep Multiplying Found Values by Two.java
new file mode 100644
index 00000000..165e4b74
--- /dev/null
+++ b/Easy/Keep Multiplying Found Values by Two.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int findFinalValue(int[] nums, int original) {
+    Set<Integer> set = new HashSet<>();
+    for (int num : nums) {
+      set.add(num);
+    }
+    while (set.contains(original)) {
+      original *= 2;
+    }
+    return original;
+  }
+}

From 0af57ee1ded7e50be94e2c326d85a2fce5e00800 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Jan 2022 07:39:04 -0800
Subject: [PATCH 0736/2175] Create All Divisions With the Highest Score of a
 Binary Array.java

---
 ...h the Highest Score of a Binary Array.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/All Divisions With the Highest Score of a Binary Array.java

diff --git a/Medium/All Divisions With the Highest Score of a Binary Array.java b/Medium/All Divisions With the Highest Score of a Binary Array.java
new file mode 100644
index 00000000..f47caba5
--- /dev/null
+++ b/Medium/All Divisions With the Highest Score of a Binary Array.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public List<Integer> maxScoreIndices(int[] nums) {
+    int n = nums.length;
+    int[] prefix = new int[n + 1];
+    for (int i = 0; i < n; i++) {
+      prefix[i + 1] = nums[i] + prefix[i];
+    }
+    int maxScore = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < n + 1; i++) {
+      int onesToRight = prefix[n] - prefix[i];
+      int zerosToLeft = i - prefix[i];
+      int currScore = zerosToLeft + onesToRight;
+      maxScore = Math.max(maxScore, currScore);
+      map.put(i, currScore);
+    }
+    List<Integer> result = new ArrayList<>();
+    for (Integer key : map.keySet()) {
+      if (map.get(key).equals(maxScore)) {
+        result.add(key);
+      }
+    }
+    return result;
+  }
+}

From 81f5b630710a85473a844aa720a63e7a487ec48f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 31 Jan 2022 07:34:49 -0800
Subject: [PATCH 0737/2175] Update Binary Tree Vertical Order Traversal.java

---
 Medium/Binary Tree Vertical Order Traversal.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Medium/Binary Tree Vertical Order Traversal.java b/Medium/Binary Tree Vertical Order Traversal.java
index 93c1004a..5d0e954f 100644
--- a/Medium/Binary Tree Vertical Order Traversal.java	
+++ b/Medium/Binary Tree Vertical Order Traversal.java	
@@ -36,15 +36,15 @@ public List<List<Integer>> verticalOrder(TreeNode root) {
     }
     return new ArrayList<>(map.values());
   }
-}
+  
 
+  private class TreeLevel {
+    TreeNode node;
+    int level;
 
-class TreeLevel {
-  TreeNode node;
-  int level;
-  
-  public TreeLevel(TreeNode node, int level) {
-    this.node = node;
-    this.level = level;
+    public TreeLevel(TreeNode node, int level) {
+      this.node = node;
+      this.level = level;
+    }
   }
 }

From c9b88ebd5c5b59dfffc3b5dd52327f7cc7b1bbd7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 31 Jan 2022 15:45:41 -0800
Subject: [PATCH 0738/2175] Update Dot Product of Two Sparse Vectors.java

---
 Medium/Dot Product of Two Sparse Vectors.java | 41 +++++++------------
 1 file changed, 14 insertions(+), 27 deletions(-)

diff --git a/Medium/Dot Product of Two Sparse Vectors.java b/Medium/Dot Product of Two Sparse Vectors.java
index 92fed72b..912d250e 100644
--- a/Medium/Dot Product of Two Sparse Vectors.java	
+++ b/Medium/Dot Product of Two Sparse Vectors.java	
@@ -1,42 +1,29 @@
 class SparseVector {
-  Map<Integer, Integer> map;
-  int[] nums;
+
+  private Map<Integer, Integer> map;
+
   SparseVector(int[] nums) {
-    this.nums = nums;
-  }
-  
-  private Map<Integer, Integer> getMap() {
-    if (map != null) {
-      return map;
-    }
-    map = new HashMap<>();
+    this.map = new HashMap<>();
     for (int i = 0; i < nums.length; i++) {
       if (nums[i] != 0) {
-        map.put(i, nums[i]);
+        this.map.put(i, nums[i]);
       }
     }
-    return map;
   }
 
   // Return the dotProduct of two sparse vectors
   public int dotProduct(SparseVector vec) {
-    Map<Integer, Integer> vecMap = vec.getMap();
-    Map<Integer, Integer> map = getMap();
-    return map.size() > vecMap.size() ? helper(vecMap, map) : helper(map, vecMap);
+    return vec.map.size() > this.map.size() ? dotProductHelper(this.map, vec.map)
+        : dotProductHelper(vec.map, this.map);
   }
-  
-  private int helper(Map<Integer, Integer> map1, Map<Integer, Integer> map2) {
-    int val = 0;
-    for (Integer key : map1.keySet()) {
-      if (map2.containsKey(key)) {
-        val += map1.get(key) * map2.get(key);
+
+  private int dotProductHelper(Map<Integer, Integer> mapOne, Map<Integer, Integer> mapTwo) {
+    int product = 0;
+    for (Integer key : mapOne.keySet()) {
+      if (mapTwo.containsKey(key)) {
+        product += mapOne.get(key) * mapTwo.get(key);
       }
     }
-    return val;
+    return product;
   }
 }
-
-// Your SparseVector object will be instantiated and called as such:
-// SparseVector v1 = new SparseVector(nums1);
-// SparseVector v2 = new SparseVector(nums2);
-// int ans = v1.dotProduct(v2);

From 0722deabaad4ab3b0c511980a24f5dd92e9a7d8f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 31 Jan 2022 17:21:56 -0800
Subject: [PATCH 0739/2175] Update Best Time to Buy and Sell Stock.java

---
 Easy/Best Time to Buy and Sell Stock.java | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/Easy/Best Time to Buy and Sell Stock.java b/Easy/Best Time to Buy and Sell Stock.java
index a30f4e9b..08df1870 100644
--- a/Easy/Best Time to Buy and Sell Stock.java	
+++ b/Easy/Best Time to Buy and Sell Stock.java	
@@ -1,14 +1,12 @@
 class Solution {
   public int maxProfit(int[] prices) {
+    int minPrice = prices[0];
     int maxProfit = 0;
-    int currMin = Integer.MAX_VALUE;
     for (int price : prices) {
-      if (price > currMin) {
-        maxProfit = Math.max(maxProfit, price - currMin);
-      }
-      else {
-        currMin = price;
+      if (price < minPrice) {
+        minPrice = price;
       }
+      maxProfit = Math.max(maxProfit, price - minPrice);
     }
     return maxProfit;
   }

From c866e5a361e840da7f2220f926537703f1295252 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Feb 2022 16:15:23 -0800
Subject: [PATCH 0740/2175] Update and rename Medium/Reconstruct Itinerary.java
 to Hard/Reconstruct Itinerary.java

---
 Hard/Reconstruct Itinerary.java   | 20 +++++++++++++
 Medium/Reconstruct Itinerary.java | 49 -------------------------------
 2 files changed, 20 insertions(+), 49 deletions(-)
 create mode 100644 Hard/Reconstruct Itinerary.java
 delete mode 100644 Medium/Reconstruct Itinerary.java

diff --git a/Hard/Reconstruct Itinerary.java b/Hard/Reconstruct Itinerary.java
new file mode 100644
index 00000000..26629d58
--- /dev/null
+++ b/Hard/Reconstruct Itinerary.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public List<String> findItinerary(List<List<String>> tickets) {
+    LinkedList<String> itinerary = new LinkedList<>();
+    Map<String, PriorityQueue<String>> graph = new HashMap<>();
+    Stack<String> stack = new Stack<>();
+    for (List<String> ticket : tickets) {
+      graph.computeIfAbsent(ticket.get(0), k -> new PriorityQueue<>()).add(ticket.get(1));
+    }
+    stack.push("JFK");
+    while (!stack.isEmpty()) {
+      String nextDestination = stack.peek();
+      if (!graph.getOrDefault(nextDestination, new PriorityQueue<>()).isEmpty()) {
+        stack.push(graph.get(nextDestination).poll());
+      } else {
+        itinerary.addFirst(stack.pop());
+      }
+    }
+    return itinerary;
+  }
+}
diff --git a/Medium/Reconstruct Itinerary.java b/Medium/Reconstruct Itinerary.java
deleted file mode 100644
index 7951bfc3..00000000
--- a/Medium/Reconstruct Itinerary.java	
+++ /dev/null
@@ -1,49 +0,0 @@
-class Solution {
-  List<String> result = null;
-  public List<String> findItinerary(List<List<String>> tickets) {
-    Map<String, List<String>> map = new HashMap<>();
-    int flights = tickets.size();
-    for (List<String> ticket : tickets) {
-      map.computeIfAbsent(ticket.get(0), k -> new ArrayList<>()).add(ticket.get(1));
-    }
-    Map<String, boolean[]> visited = new HashMap<>();
-    for (Map.Entry<String, List<String>> entry : map.entrySet()) {
-      Collections.sort(entry.getValue());
-      visited.put(entry.getKey(), new boolean[entry.getValue().size()]);
-    }
-    LinkedList<String> route = new LinkedList<String>();
-    route.add("JFK");
-    backtrack(map, visited, flights, route, "JFK");
-    return result;
-  }
-  
-  private boolean backtrack(
-    Map<String, List<String>> map,
-    Map<String, boolean[]> visited,
-    int flights,
-    LinkedList<String> route,
-    String origin
-  ) {
-    if (route.size() == (flights + 1)) {
-      result = (List<String>) route.clone();
-      return true;
-    }
-    if (!map.containsKey(origin)) {
-      return false;
-    }
-    boolean[] visit = visited.get(origin);
-    for (int i = 0; i < map.get(origin).size(); i++) {
-      if (!visit[i]) {
-        visit[i] = true;
-        route.add(map.get(origin).get(i));
-        boolean res = backtrack(map, visited, flights, route, map.get(origin).get(i));
-        route.pollLast();
-        visit[i] = false;
-        if (res) {
-          return res;
-        }
-      }
-    }
-    return false;
-  }
-}

From c285daeedddc9c1f32ac73faeb97056c560685d8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 2 Feb 2022 07:55:45 -0800
Subject: [PATCH 0741/2175] Create Lowest Common Ancestor of a Binary Tree
 III.java

---
 ... Common Ancestor of a Binary Tree III.java | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Medium/Lowest Common Ancestor of a Binary Tree III.java

diff --git a/Medium/Lowest Common Ancestor of a Binary Tree III.java b/Medium/Lowest Common Ancestor of a Binary Tree III.java
new file mode 100644
index 00000000..26269fcc
--- /dev/null
+++ b/Medium/Lowest Common Ancestor of a Binary Tree III.java	
@@ -0,0 +1,38 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node parent;
+};
+*/
+
+class Solution {
+  public Node lowestCommonAncestor(Node p, Node q) {
+    int pDepth = getDepth(p);
+    int qDepth = getDepth(q);
+    while (pDepth > qDepth) {
+      pDepth--;
+      p = p.parent;
+    }
+    while (pDepth < qDepth) {
+      qDepth--;
+      q = q.parent;
+    }
+    while (p != q) {
+      p = p.parent;
+      q = q.parent;
+    }
+    return p;
+  }
+  
+  private int getDepth(Node node) {
+    int depth = 0;
+    while (node != null) {
+      depth++;
+      node = node.parent;
+    }
+    return depth;
+  }
+}

From f2e2544ba6b4e9bff055c67a4fe69548f6b25364 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 2 Feb 2022 14:41:47 -0800
Subject: [PATCH 0742/2175] Update Minimum Add to Make Parentheses Valid.java

---
 ...Minimum Add to Make Parentheses Valid.java | 20 +++++++++----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/Medium/Minimum Add to Make Parentheses Valid.java b/Medium/Minimum Add to Make Parentheses Valid.java
index bc78b451..f119bfe7 100644
--- a/Medium/Minimum Add to Make Parentheses Valid.java	
+++ b/Medium/Minimum Add to Make Parentheses Valid.java	
@@ -1,20 +1,18 @@
 class Solution {
-  public int minAddToMakeValid(String S) {
+  public int minAddToMakeValid(String s) {
     int count = 0;
-    int open = 0;
-    for (char c : S.toCharArray()) {
+    Stack<Character> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
       if (c == '(') {
-        open++;
-      }
-      else {
-        if (open != 0) {
-          open--;
-        }
-        else {
+        stack.push(c);
+      } else {
+        if (stack.isEmpty()) {
           count++;
+        } else {
+          stack.pop();
         }
       }
     }
-    return count + open;
+    return count + stack.size();
   }
 }

From edd245eda95db7a81d6c24d14cf06d51f98c4193 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Feb 2022 11:52:10 -0800
Subject: [PATCH 0743/2175] Update and rename Easy/N-ary Tree Level Order
 Traversal.java to Medium/N-ary Tree Level Order Traversal.java

---
 Easy/N-ary Tree Level Order Traversal.java   | 42 --------------------
 Medium/N-ary Tree Level Order Traversal.java | 42 ++++++++++++++++++++
 2 files changed, 42 insertions(+), 42 deletions(-)
 delete mode 100644 Easy/N-ary Tree Level Order Traversal.java
 create mode 100644 Medium/N-ary Tree Level Order Traversal.java

diff --git a/Easy/N-ary Tree Level Order Traversal.java b/Easy/N-ary Tree Level Order Traversal.java
deleted file mode 100644
index 11aac2e6..00000000
--- a/Easy/N-ary Tree Level Order Traversal.java	
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-// Definition for a Node.
-class Node {
-    public int val;
-    public List<Node> children;
-
-    public Node() {}
-
-    public Node(int _val,List<Node> _children) {
-        val = _val;
-        children = _children;
-    }
-};
-*/
-class Solution {
-    public List<List<Integer>> levelOrder(Node root) {
-        List<List<Integer>> values = new ArrayList<>();
-        
-        if (root == null) {
-            return values;
-        }
-        
-        Queue<Node> queue = new LinkedList<>();
-        queue.add(root);
-        
-        while (!queue.isEmpty()) {
-            int n = queue.size();
-            List<Integer> temp = new ArrayList<>();
-            
-            while(n-- > 0) {
-                Node node = queue.remove();
-                temp.add(node.val);
-                List<Node> childrens = node.children;
-                queue.addAll(childrens);
-            }
-            
-            values.add(temp);
-        }
-        
-        return values;
-    }
-}
diff --git a/Medium/N-ary Tree Level Order Traversal.java b/Medium/N-ary Tree Level Order Traversal.java
new file mode 100644
index 00000000..29373207
--- /dev/null
+++ b/Medium/N-ary Tree Level Order Traversal.java	
@@ -0,0 +1,42 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+  public List<List<Integer>> levelOrder(Node root) {
+    if (root == null) {
+      return new ArrayList<>();
+    }
+    List<List<Integer>> result = new ArrayList<>();
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      List<Integer> level = new ArrayList<>();
+      while (size-- > 0) {
+        Node removed = queue.remove();
+        level.add(removed.val);
+        for (Node child : removed.children) {
+          queue.add(child);
+        }
+      }
+      result.add(level);
+    }
+    return result;
+  }
+}

From fd74e1f50150fdb43efd9cc4c3e9c3bbc6eb1b2c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Feb 2022 12:21:57 -0800
Subject: [PATCH 0744/2175] Update Shortest Path in Binary Matrix.java

---
 Medium/Shortest Path in Binary Matrix.java | 36 +++++++++++++---------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/Medium/Shortest Path in Binary Matrix.java b/Medium/Shortest Path in Binary Matrix.java
index d73302d5..0649b9b0 100644
--- a/Medium/Shortest Path in Binary Matrix.java	
+++ b/Medium/Shortest Path in Binary Matrix.java	
@@ -1,34 +1,40 @@
 class Solution {
-  int[][] dirs = {{0,1},{0,-1},{1,0},{-1,0},{1,-1},{-1,1},{-1,-1},{1,1}};
   public int shortestPathBinaryMatrix(int[][] grid) {
-    int rows = grid.length;
-    int cols = grid[0].length;
-    if (grid[0][0] == 1 || grid[rows - 1][cols - 1] == 1) {
+    int n = grid.length;
+    if (n == 0 || grid[0][0] == 1 || grid[n - 1][n - 1] == 1) {
       return -1;
     }
-    boolean[][] visited = new boolean[rows][cols];
     Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{0, 0});
+    int numberOfSteps = 0;
+    boolean[][] visited = new boolean[n][n];
+    queue.add(new int[] {0, 0});
     visited[0][0] = true;
-    int steps = 0;
     while (!queue.isEmpty()) {
       int size = queue.size();
       while (size-- > 0) {
         int[] removed = queue.remove();
-        if (removed[0] == (rows - 1) && removed[1] == (cols - 1)) {
-          return steps + 1;
+        if (removed[0] == n - 1 && removed[1] == n - 1) {
+          return numberOfSteps + 1;
         }
-        for (int i = 0; i < dirs.length; i++) {
-          int newX = removed[0] + dirs[i][0];
-          int newY = removed[1] + dirs[i][1];
-          if (newX >= 0 && newX < rows && newY >= 0 && newY < cols && !visited[newX][newY] && grid[newX][newY] == 0) {
-            queue.add(new int[]{newX, newY});
+        for (int[] dir : EIGHT_DIRS) {
+          int newX = removed[0] + dir[0];
+          int newY = removed[1] + dir[1];
+          if (newX >= 0
+              && newX < n
+              && newY >= 0
+              && newY < n
+              && !visited[newX][newY]
+              && grid[newX][newY] == 0) {
+            queue.add(new int[] {newX, newY});
             visited[newX][newY] = true;
           }
         }
       }
-      steps++;
+      numberOfSteps++;
     }
     return -1;
   }
+
+  private static final int[][] EIGHT_DIRS = {
+    {0,1},{0,-1},{1,0},{-1,0},{1,-1},{-1,1},{-1,-1},{1,1}};
 }

From 9e11021284707981b324fadd6e3d45d3e3223372 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 4 Feb 2022 07:52:52 -0800
Subject: [PATCH 0745/2175] Update Contiguous Array.java

---
 Medium/Contiguous Array.java | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/Medium/Contiguous Array.java b/Medium/Contiguous Array.java
index 554d8c65..204c9102 100644
--- a/Medium/Contiguous Array.java	
+++ b/Medium/Contiguous Array.java	
@@ -2,17 +2,16 @@ class Solution {
   public int findMaxLength(int[] nums) {
     Map<Integer, Integer> map = new HashMap<>();
     map.put(0, -1);
-    int maxLen = 0;
+    int maxLength = 0;
     int count = 0;
     for (int i = 0; i < nums.length; i++) {
       count += nums[i] == 0 ? -1 : 1;
       if (map.containsKey(count)) {
-        maxLen = Math.max(maxLen, i - map.get(count));
-      }
-      else {
+        maxLength = Math.max(maxLength, i - map.get(count));
+      } else {
         map.put(count, i);
       }
     }
-    return maxLen;
+    return maxLength;
   }
 }

From 630e3dd5b8d912d790fadf37b4d14bf193701fb3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 4 Feb 2022 14:00:28 -0800
Subject: [PATCH 0746/2175] Update Nested List Weight Sum.java

---
 Easy/Nested List Weight Sum.java | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/Easy/Nested List Weight Sum.java b/Easy/Nested List Weight Sum.java
index 65fe828b..4a98107d 100644
--- a/Easy/Nested List Weight Sum.java	
+++ b/Easy/Nested List Weight Sum.java	
@@ -22,34 +22,33 @@
  *     public void add(NestedInteger ni);
  *
  *     // @return the nested list that this NestedInteger holds, if it holds a nested list
- *     // Return null if this NestedInteger holds a single integer
+ *     // Return empty list if this NestedInteger holds a single integer
  *     public List<NestedInteger> getList();
  * }
  */
 class Solution {
   public int depthSum(List<NestedInteger> nestedList) {
-    int level = 1;
     Queue<NestedInteger> queue = new LinkedList<>();
-    int sum = 0;
+    int currLevel = 1;
     for (NestedInteger nestedInteger : nestedList) {
       queue.add(nestedInteger);
     }
+    int totalSum = 0;
     while (!queue.isEmpty()) {
       int size = queue.size();
       while (size-- > 0) {
-        NestedInteger nestedInteger = queue.remove();
-        if (nestedInteger.isInteger()) {
-          sum += nestedInteger.getInteger() * level;
-        }
-        else {
-          List<NestedInteger> nList = nestedInteger.getList();
-          for (NestedInteger nInteger : nList) {
-            queue.add(nInteger);
+        NestedInteger removed = queue.remove();
+        if (removed.isInteger()) {
+          totalSum += currLevel * removed.getInteger();
+        } else {
+          List<NestedInteger> nestedIntegers = removed.getList();
+          for (NestedInteger nestedInteger : nestedIntegers) {
+            queue.add(nestedInteger);
           }
         }
       }
-      level++;
+      currLevel++;
     }
-    return sum;
+    return totalSum;
   }
 }

From b057e54e481abd1c69d4c64ca895f6c2e1bd8ad5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 4 Feb 2022 16:20:29 -0800
Subject: [PATCH 0747/2175] Update Nested List Weight Sum II.java

---
 Medium/Nested List Weight Sum II.java | 31 ++++++++++++---------------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/Medium/Nested List Weight Sum II.java b/Medium/Nested List Weight Sum II.java
index c5fcc6e8..f804c67b 100644
--- a/Medium/Nested List Weight Sum II.java	
+++ b/Medium/Nested List Weight Sum II.java	
@@ -22,36 +22,33 @@
  *     public void add(NestedInteger ni);
  *
  *     // @return the nested list that this NestedInteger holds, if it holds a nested list
- *     // Return null if this NestedInteger holds a single integer
+ *     // Return empty list if this NestedInteger holds a single integer
  *     public List<NestedInteger> getList();
  * }
  */
+import java.util.Map.Entry;
+
+
 class Solution {
   public int depthSumInverse(List<NestedInteger> nestedList) {
     Queue<NestedInteger> queue = new LinkedList<>();
-    int prevSum = 0;
+    queue.addAll(nestedList);
+    int totalSum = 0;
     int currSum = 0;
-    for (NestedInteger nestedInteger : nestedList) {
-      queue.add(nestedInteger);
-    }
     while (!queue.isEmpty()) {
       int size = queue.size();
       int levelSum = 0;
       while (size-- > 0) {
-        NestedInteger removed = queue.remove();
-        if (removed.isInteger()) {
-          levelSum += removed.getInteger();
-        }
-        else {
-          List<NestedInteger> nList = removed.getList();
-          for (NestedInteger nInteger : nList) {
-            queue.add(nInteger);
-          }
+        NestedInteger nestedInteger = queue.remove();
+        if (nestedInteger.isInteger()) {
+          levelSum += nestedInteger.getInteger();
+        } else {
+          queue.addAll(nestedInteger.getList());
         }
       }
-      prevSum += levelSum;
-      currSum += prevSum;
+      currSum += levelSum;
+      totalSum += currSum;
     }
-    return currSum;
+    return totalSum;
   }
 }

From 0cb47aa954f87270f7a90be546c72b339f7cdefd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 5 Feb 2022 07:20:21 -0800
Subject: [PATCH 0748/2175] Update Palindrome Permutation.java

---
 Easy/Palindrome Permutation.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Easy/Palindrome Permutation.java b/Easy/Palindrome Permutation.java
index f1d5b084..ce4bccb8 100644
--- a/Easy/Palindrome Permutation.java	
+++ b/Easy/Palindrome Permutation.java	
@@ -1,13 +1,13 @@
 class Solution {
   public boolean canPermutePalindrome(String s) {
-    int[] count = new int[256];
+    Map<Character, Integer> frequencyMap = new HashMap<>();
     for (char c : s.toCharArray()) {
-      count[(int) c]++;
+      frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) + 1);
     }
     boolean oddFound = false;
-    for (int i = 0; i < 256; i++) {
-      if (count[i] % 2 != 0) {
-        if (s.length() % 2 == 0 || oddFound) {
+    for (Character key : frequencyMap.keySet()) {
+      if (frequencyMap.get(key) % 2 != 0) {
+        if (oddFound) {
           return false;
         }
         oddFound = true;

From d8985bb5d285aa989a36fa9f025ae169d9a95a1b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 5 Feb 2022 16:00:19 -0800
Subject: [PATCH 0749/2175] Create Minimum Sum of Four Digit Number After
 Splitting Digits.java

---
 ...m of Four Digit Number After Splitting Digits.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Minimum Sum of Four Digit Number After Splitting Digits.java

diff --git a/Easy/Minimum Sum of Four Digit Number After Splitting Digits.java b/Easy/Minimum Sum of Four Digit Number After Splitting Digits.java
new file mode 100644
index 00000000..5929e314
--- /dev/null
+++ b/Easy/Minimum Sum of Four Digit Number After Splitting Digits.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int minimumSum(int num) {
+    int[] digits = new int[4];
+    for (int i = 0; i < 4; i++) {
+      digits[i] = num % 10;
+      num /= 10;
+    }
+    Arrays.sort(digits);
+    return (digits[0] * 10 + digits[2]) + (digits[1] * 10 + digits[3]);
+  }
+}

From c9c38c96b0c879602577bbb236affb9f8d3d46f4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 5 Feb 2022 16:16:54 -0800
Subject: [PATCH 0750/2175] Create Partition Array According to Given
 Pivot.java

---
 ...tition Array According to Given Pivot.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Partition Array According to Given Pivot.java

diff --git a/Medium/Partition Array According to Given Pivot.java b/Medium/Partition Array According to Given Pivot.java
new file mode 100644
index 00000000..740b1707
--- /dev/null
+++ b/Medium/Partition Array According to Given Pivot.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int[] pivotArray(int[] nums, int pivot) {
+    int[] result = new int[nums.length];
+    int leftIdx = 0;
+    int rightIdx = nums.length - 1;
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] < pivot) {
+        result[leftIdx++] = nums[i];
+      }
+      int tempIdx = nums.length - 1 - i;
+      if (nums[tempIdx] > pivot) {
+        result[rightIdx--] = nums[tempIdx];
+      }
+    }
+    while (leftIdx <= rightIdx) {
+      result[leftIdx++] = pivot;
+    }
+    return result;
+  }
+}

From 32e442131c11189e70d0fc03816f1b487f6c69ae Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 5 Feb 2022 16:24:06 -0800
Subject: [PATCH 0751/2175] Update Remove Duplicates From Sorted Array II.java

---
 ...emove Duplicates From Sorted Array II.java | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/Medium/Remove Duplicates From Sorted Array II.java b/Medium/Remove Duplicates From Sorted Array II.java
index 90a056c7..63879666 100644
--- a/Medium/Remove Duplicates From Sorted Array II.java	
+++ b/Medium/Remove Duplicates From Sorted Array II.java	
@@ -1,20 +1,19 @@
 class Solution {
   public int removeDuplicates(int[] nums) {
-    int slow = 0;
-    int fast = 0;
+    int startIdx = 0;
     int n = nums.length;
-    while (fast < n) {
-      int currNum = nums[fast];
+    int currIdx = 0;
+    while (currIdx < n) {
+      int currValue = nums[currIdx];
       int count = 0;
-      while (fast < n && currNum == nums[fast]) {
-        fast++;
+      while (currIdx < n && nums[currIdx] == currValue) {
+        currIdx++;
         count++;
       }
-      int frequency = Math.min(count, 2);
-      while (frequency-- > 0) {
-        nums[slow++] = currNum;
+      for (int i = 0; i < Math.min(2, count); i++) {
+        nums[startIdx++] = currValue;
       }
     }
-    return slow;
+    return startIdx;
   }
 }

From 7f56b04e26db6fe702d443a611f1b7c109f0da14 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Feb 2022 07:57:30 -0800
Subject: [PATCH 0752/2175] Create Sort Even and Odd Indices Independently.java

---
 ...rt Even and Odd Indices Independently.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Sort Even and Odd Indices Independently.java

diff --git a/Easy/Sort Even and Odd Indices Independently.java b/Easy/Sort Even and Odd Indices Independently.java
new file mode 100644
index 00000000..7b7e8203
--- /dev/null
+++ b/Easy/Sort Even and Odd Indices Independently.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int[] sortEvenOdd(int[] nums) {
+    PriorityQueue<Integer> oddIndices = new PriorityQueue<>((o1, o2) -> o2 - o1);
+    PriorityQueue<Integer> evenIndices = new PriorityQueue<>();
+    for (int i = 0; i < nums.length; i++) {
+      if (i % 2 == 0) {
+        evenIndices.add(nums[i]);
+      } else {
+        oddIndices.add(nums[i]);
+      }
+    }
+    int[] result = new int[nums.length];
+    for (int i = 0; i < nums.length; i++) {
+      if (i % 2 == 0) {
+        result[i] = evenIndices.poll();
+      } else {
+        result[i] = oddIndices.poll();
+      }
+    }
+    return result;
+  }
+}

From b89f7fbc9774aa9f09ca1ebafa9ba4bf2d20b3d5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Feb 2022 15:03:28 -0800
Subject: [PATCH 0753/2175] Create Smallest Value of the Rearranged Number.java

---
 ...allest Value of the Rearranged Number.java | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 Medium/Smallest Value of the Rearranged Number.java

diff --git a/Medium/Smallest Value of the Rearranged Number.java b/Medium/Smallest Value of the Rearranged Number.java
new file mode 100644
index 00000000..13dfdc46
--- /dev/null
+++ b/Medium/Smallest Value of the Rearranged Number.java	
@@ -0,0 +1,35 @@
+class Solution {
+  public long smallestNumber(long num) {
+    return num < 0 ?
+        getArrangement(Math.abs(num), (o1, o2) -> (int) (o2 - o1), true) * -1 :
+        getArrangement(num, (o1, o2) -> (int) (o1 - o2), false);
+  }
+
+  private long getArrangement(long num, Comparator<Long> comparator, boolean zeroAtEnd) {
+    PriorityQueue<Long> pq = new PriorityQueue<>(comparator);
+    long zeroMultiple = 1;
+    while (num > 0) {
+      long remainder = num % 10;
+      if (remainder == 0) {
+        zeroMultiple *= 10;
+      } else {
+        pq.add(remainder);
+      }
+      num /= 10;
+    }
+    long result = 0;
+    if (!pq.isEmpty()) {
+      result = result * 10 + pq.poll();
+    }
+    if (!zeroAtEnd) {
+      result *= zeroMultiple;
+    }
+    while (!pq.isEmpty()) {
+      result = result * 10 + pq.poll();
+    }
+    if (zeroAtEnd) {
+      result *= zeroMultiple;
+    }
+    return result;
+  }
+}

From 4421795fbe729da6cac9ecd344e2ffed450bbe5c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Feb 2022 20:47:12 -0800
Subject: [PATCH 0754/2175] Update Custom Sort String.java

---
 Medium/Custom Sort String.java | 32 +++++++++++---------------------
 1 file changed, 11 insertions(+), 21 deletions(-)

diff --git a/Medium/Custom Sort String.java b/Medium/Custom Sort String.java
index 1fe011ce..248a721a 100644
--- a/Medium/Custom Sort String.java	
+++ b/Medium/Custom Sort String.java	
@@ -1,26 +1,16 @@
 class Solution {
-  public String customSortString(String S, String T) {
-    Set<Character> set = new HashSet<>();
-    for (int i = 0; i < S.length(); i++) {
-      set.add(S.charAt(i));
-    }
+  public String customSortString(String order, String s) {
     Map<Character, Integer> map = new HashMap<>();
-    StringBuilder sb = new StringBuilder();
-    for (char c : T.toCharArray()) {
-      if (set.contains(c)) {
-        map.put(c, map.getOrDefault(c, 0) + 1);
-      }
-      else {
-        sb.append(c);
-      }
-    }
-    for (int i = 0; i < S.length(); i++) {
-      char c = S.charAt(i);
-      int count = map.getOrDefault(c, 0);
-      while (count-- > 0) {
-        sb.append(c);
-      }
+    int position = 1;
+    for (char c : order.toCharArray()) {
+      map.put(c, position++);
     }
-    return sb.toString();
+    return s.chars()
+        .mapToObj(c -> (char) c)
+        .sorted(Comparator.comparing(o -> map.getOrDefault(o, 0)))
+        .collect(Collector.of(StringBuilder::new,
+          StringBuilder::append,
+          StringBuilder::append,
+          StringBuilder::toString));
   }
 }

From 8954b3387750aad209b5798d0dbd1a9949b811ef Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Feb 2022 16:27:37 -0800
Subject: [PATCH 0755/2175] Update Add Digits.java

---
 Easy/Add Digits.java | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/Easy/Add Digits.java b/Easy/Add Digits.java
index c701c82a..a17de297 100644
--- a/Easy/Add Digits.java	
+++ b/Easy/Add Digits.java	
@@ -1,17 +1,13 @@
 class Solution {
   public int addDigits(int num) {
-    while (String.valueOf(num).length() > 1) {
-      num = getDigitSum(num);
+    if (num / 10 == 0) {
+      return num;
     }
-    return num;
-  }
-  
-  private int getDigitSum(int n) {
-    int newNum = 0;
-    while (n > 0) {
-      newNum += n % 10;
-      n /= 10;
+    int digitSum = 0;
+    while (num > 0) {
+      digitSum += num % 10;
+      num /= 10;
     }
-    return newNum;
+    return addDigits(digitSum);
   }
 }

From a2082ac9bedec6356904f23f94c4489a2846ab49 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Feb 2022 16:45:32 -0800
Subject: [PATCH 0756/2175] Update Add Two Numbers.java

---
 Medium/Add Two Numbers.java | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/Medium/Add Two Numbers.java b/Medium/Add Two Numbers.java
index 4917bf04..8245945b 100644
--- a/Medium/Add Two Numbers.java	
+++ b/Medium/Add Two Numbers.java	
@@ -3,34 +3,34 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
   public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-    ListNode ans = new ListNode(-1);
-    ListNode curr = ans;
+    ListNode root = new ListNode(-1);
+    ListNode curr = root;
     int carry = 0;
-    while (l1 != null || l2 != null || carry > 0) {
-      int temp = carry;
+    while (l1 != null || l2 != null || carry != 0) {
+      int currSum = carry;
       if (l1 != null && l2 != null) {
-        temp += l1.val + l2.val;
+        currSum += l1.val + l2.val;
         l1 = l1.next;
         l2 = l2.next;
-      }
-      else if (l1 != null && l2 == null) {
-        temp += l1.val;
+      } else if (l1 != null && l2 == null) {
+        currSum += l1.val;
         l1 = l1.next;
-      }
-      else if (l1 == null && l2 != null) {
-        temp += l2.val;
+      } else if (l1 == null && l2 != null) {
+        currSum += l2.val;
         l2 = l2.next;
       }
-      carry = temp > 9 ? temp / 10 : 0;
-      temp = temp % 10;
-      curr.next = new ListNode(temp);
+      carry = currSum > 9 ? 1 : 0;
+      currSum %= 10;
+      curr.next = new ListNode(currSum);
       curr = curr.next;
     }
-    return ans.next;
+    return root.next;
   }
 }

From e492bba5c31a264503f6c853869013a44410500c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Feb 2022 07:35:04 -0800
Subject: [PATCH 0757/2175] Update Design Browser History.java

---
 Medium/Design Browser History.java | 39 ++++++++++++------------------
 1 file changed, 15 insertions(+), 24 deletions(-)

diff --git a/Medium/Design Browser History.java b/Medium/Design Browser History.java
index fb5db3bb..8aa9f71f 100644
--- a/Medium/Design Browser History.java	
+++ b/Medium/Design Browser History.java	
@@ -1,40 +1,31 @@
 class BrowserHistory {
-  
-  Node root;
+
+  private Stack<String> history;
+  private Stack<String> future;
+
   public BrowserHistory(String homepage) {
-    root = new Node(homepage);
+    this.history = new Stack<>();
+    this.history.push(homepage);
+    this.future = new Stack<>();
   }
 
   public void visit(String url) {
-    Node node = new Node(url);
-    root.next = null;
-    root.next = node;
-    node.prev = root;
-    root = root.next;
+    this.future.removeAllElements();
+    this.history.push(url);
   }
 
   public String back(int steps) {
-    while (steps-- > 0 && root.prev != null) {
-      root = root.prev;
+    while (steps-- > 0 && this.history.size() > 1) {
+      this.future.push(this.history.pop());
     }
-    return root.val;
+    return this.history.peek();
   }
 
   public String forward(int steps) {
-    while (steps-- > 0 && root.next != null) {
-      root = root.next;
+    while (steps-- > 0 && !this.future.isEmpty()) {
+      this.history.push(this.future.pop());
     }
-    return root.val;
-  }
-}
-
-class Node {
-  String val;
-  Node next;
-  Node prev;
-  
-  public Node(String val) {
-    this.val = val;
+    return this.history.peek();
   }
 }
 

From 66d3dd5e39243002388579b3a0640bdf2f7298b7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Feb 2022 13:44:07 -0800
Subject: [PATCH 0758/2175] Create Min Cost to Connect All Points.java

---
 Medium/Min Cost to Connect All Points.java | 80 ++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 Medium/Min Cost to Connect All Points.java

diff --git a/Medium/Min Cost to Connect All Points.java b/Medium/Min Cost to Connect All Points.java
new file mode 100644
index 00000000..15cc689b
--- /dev/null
+++ b/Medium/Min Cost to Connect All Points.java	
@@ -0,0 +1,80 @@
+class Solution {
+  public int minCostConnectPoints(int[][] points) {
+    int n = points.length;
+    PriorityQueue<Edge> priorityQueue = new PriorityQueue<>((x, y) -> x.cost - y.cost);
+    UnionFind unionFind = new UnionFind(n);
+    for (int i = 0; i < n; i++) {
+      int[] coordinate = points[i];
+      for (int j = i + 1; j < n; j++) {
+        int[] secondCoordinate = points[j];
+        int cost = Math.abs(coordinate[0] - secondCoordinate[0]) + Math.abs(coordinate[1] - secondCoordinate[1]);
+        Edge edge = new Edge(i, j, cost);
+        priorityQueue.add(edge);
+      }
+    }
+    int minimumCost = 0;
+    int totalEdges = n - 1;
+    while (!priorityQueue.isEmpty() && totalEdges > 0) {
+      Edge edge = priorityQueue.poll();
+      if (!unionFind.connected(edge.pointOne, edge.pointTwo)) {
+        unionFind.union(edge.pointOne, edge.pointTwo);
+        minimumCost += edge.cost;
+        totalEdges--;
+      }
+    }
+    return minimumCost;
+  }
+
+  private static class Edge {
+    int pointOne;
+    int pointTwo;
+    int cost;
+
+    public Edge(int pointOne, int pointTwo, int cost) {
+      this.pointOne = pointOne;
+      this.pointTwo = pointTwo;
+      this.cost = cost;
+    }
+  }
+
+  private static class UnionFind {
+
+    private final int[] root;
+    private final int[] rank;
+
+    public UnionFind(int size) {
+      this.root = new int[size];
+      this.rank = new int[size];
+      for (int i = 0; i < size; i++) {
+        this.root[i] = i;
+        this.rank[i] = 1;
+      }
+    }
+
+    public void union(int nodeOne, int nodeTwo) {
+      int rootOne = find(nodeOne);
+      int rootTwo = find(nodeTwo);
+      if (rootOne != rootTwo) {
+        if (this.rank[rootOne] > this.rank[rootTwo]) {
+          this.root[rootTwo] = rootOne;
+        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
+          this.root[rootOne] = rootTwo;
+        } else {
+          this.root[rootTwo] = rootOne;
+          this.rank[rootOne]++;
+        }
+      }
+    }
+
+    public int find(int node) {
+      if (node == root[node]) {
+        return node;
+      }
+      return root[node] = find(root[node]);
+    }
+
+    public boolean connected(int nodeOne, int nodeTwo) {
+      return find(nodeOne) == find(nodeTwo);
+    }
+  }
+}

From 63c3f75341f6510cb6617050ed2c3359aa389181 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Feb 2022 16:52:49 -0800
Subject: [PATCH 0759/2175] Create Connecting Cities With Minimum Cost.java

---
 .../Connecting Cities With Minimum Cost.java  | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 Medium/Connecting Cities With Minimum Cost.java

diff --git a/Medium/Connecting Cities With Minimum Cost.java b/Medium/Connecting Cities With Minimum Cost.java
new file mode 100644
index 00000000..e1a90f09
--- /dev/null
+++ b/Medium/Connecting Cities With Minimum Cost.java	
@@ -0,0 +1,59 @@
+class Solution {
+  public int minimumCost(int n, int[][] connections) {
+    Arrays.sort(connections, Comparator.comparingInt(a -> a[2]));
+    UnionFind unionFind = new UnionFind(n);
+    int totalCost = 0;
+    for (int[] connection : connections) {
+      int nodeOne = connection[0] - 1;
+      int nodeTwo = connection[1] - 1;
+      if (!unionFind.isConnected(nodeOne, nodeTwo)) {
+        totalCost += connection[2];
+        unionFind.union(nodeOne, nodeTwo);
+        n--;
+      }
+    }
+    return n == 1 ? totalCost : -1;
+  }
+  
+  private static class UnionFind {
+
+    private final int[] root;
+    private final int[] rank;
+
+    public UnionFind(int size) {
+      this.root = new int[size];
+      this.rank = new int[size];
+      for (int i = 0; i < size; i++) {
+        this.root[i] = i;
+        this.rank[i] = 1;
+      }
+    }
+
+    public void union(int nodeOne, int nodeTwo) {
+      int rootOne = find(nodeOne);
+      int rootTwo = find(nodeTwo);
+      if (rootOne != rootTwo) {
+        if (this.rank[rootOne] > this.rank[rootTwo]) {
+          this.root[rootTwo] = rootOne;
+        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
+          this.root[rootOne] = rootTwo;
+        } else {
+          this.root[rootTwo] = rootOne;
+          this.rank[rootOne]++;
+        }
+      }
+    }
+
+
+    public int find(int node) {
+      if (node == root[node]) {
+        return node;
+      }
+      return root[node] = find(root[node]);
+    }
+
+    public boolean isConnected(int nodeOne, int nodeTwo) {
+      return find(nodeOne) == find(nodeTwo);
+    }
+  }
+}

From c51290124e9e6ad6f1cc941bf7ad0f1c3afa85b7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Feb 2022 17:03:45 -0800
Subject: [PATCH 0760/2175] Update K-diff Pairs in an Array.java

---
 Easy/K-diff Pairs in an Array.java | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/Easy/K-diff Pairs in an Array.java b/Easy/K-diff Pairs in an Array.java
index 72aef035..b2a9e7c7 100644
--- a/Easy/K-diff Pairs in an Array.java	
+++ b/Easy/K-diff Pairs in an Array.java	
@@ -1,21 +1,18 @@
 class Solution {
   public int findPairs(int[] nums, int k) {
-    Arrays.sort(nums);
-    int left = 0;
-    int right = 1;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
     int count = 0;
-    while (left < nums.length && right < nums.length) {
-      if (left == right || nums[right] - nums[left] < k) {
-        right++;
-      }
-      else if (nums[right] - nums[left] > k) {
-        left++;
-      }
-      else {
-        left++;
-        count++;
-        while (left < nums.length && nums[left] == nums[left - 1]) {
-          left++;
+    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+      if (k == 0) {
+        if (entry.getValue() >= 2) {
+          count++;
+        }
+      } else {
+        if (map.containsKey(entry.getKey() + k)) {
+          count++;
         }
       }
     }

From 8446b2cde0307d4c320c719d9d5116a5fc5d8cea Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Feb 2022 17:29:57 -0800
Subject: [PATCH 0761/2175] Create Design an Ordered Stream.java

---
 Easy/Design an Ordered Stream.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Design an Ordered Stream.java

diff --git a/Easy/Design an Ordered Stream.java b/Easy/Design an Ordered Stream.java
new file mode 100644
index 00000000..68c1eba7
--- /dev/null
+++ b/Easy/Design an Ordered Stream.java	
@@ -0,0 +1,23 @@
+class OrderedStream {
+  private String[] stream;
+  private int currIdx;
+  public OrderedStream(int n) {
+    this.stream = new String[n];
+    this.currIdx = 0;
+  }
+
+  public List<String> insert(int idKey, String value) {
+    this.stream[idKey - 1] = value;
+    List<String> result = new ArrayList<>();
+    while (this.currIdx < stream.length && this.stream[this.currIdx] != null) {
+      result.add(this.stream[this.currIdx++]);
+    }
+    return result;
+  }
+}
+
+/**
+ * Your OrderedStream object will be instantiated and called as such:
+ * OrderedStream obj = new OrderedStream(n);
+ * List<String> param_1 = obj.insert(idKey,value);
+ */

From 9b30ec2e3655c55e6bb9239307a13c5b182babc4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Feb 2022 12:24:48 -0800
Subject: [PATCH 0762/2175] Create Longest Word With All Prefixes.java

---
 Medium/Longest Word With All Prefixes.java | 53 ++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 Medium/Longest Word With All Prefixes.java

diff --git a/Medium/Longest Word With All Prefixes.java b/Medium/Longest Word With All Prefixes.java
new file mode 100644
index 00000000..567aea3a
--- /dev/null
+++ b/Medium/Longest Word With All Prefixes.java	
@@ -0,0 +1,53 @@
+class Solution {
+  public String longestWord(String[] words) {
+    TrieNode root = new TrieNode();
+    root.isWord = true;
+    Map<Integer, PriorityQueue<String>> map = new TreeMap<>((o1, o2) -> o2 - o1);
+    for (String word : words) {
+      addToTrie(word, root);
+      map.computeIfAbsent(word.length(), k -> new PriorityQueue<>(String::compareTo)).add(word);
+    }
+    for (Integer key : map.keySet()) {
+      PriorityQueue<String> priorityQueue = map.get(key);
+      while (!priorityQueue.isEmpty()) {
+        String candidateWord = priorityQueue.poll();
+        if (wordContainAllPrefixes(candidateWord, root)) {
+          return candidateWord;
+        }
+      }
+    }
+    return "";
+  }
+
+  private boolean wordContainAllPrefixes(String word, TrieNode root) {
+    TrieNode curr = root;
+    for (int i = 0; i < word.length(); i++) {
+      if (!curr.isWord) {
+        return false;
+      }
+      curr = curr.children.get(word.charAt(i));
+    }
+    return curr.isWord;
+  }
+
+  private void addToTrie(String word, TrieNode root) {
+    TrieNode curr = root;
+    for (int i = 0; i < word.length(); i++) {
+      if (!curr.children.containsKey(word.charAt(i))) {
+        curr.children.put(word.charAt(i), new TrieNode());
+      }
+      curr = curr.children.get(word.charAt(i));
+    }
+    curr.isWord = true;
+  }
+
+  private static class TrieNode {
+    Map<Character, TrieNode> children;
+    boolean isWord;
+
+    public TrieNode() {
+      this.children = new HashMap<>();
+      this.isWord = false;
+    }
+  }
+}

From 9d3ace1200799f39f5f933cab6af61a9ac6350d3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Feb 2022 15:09:24 -0800
Subject: [PATCH 0763/2175] Update Print in Order.java

---
 Concurrency/Print in Order.java | 81 +++++++++++++++------------------
 1 file changed, 36 insertions(+), 45 deletions(-)

diff --git a/Concurrency/Print in Order.java b/Concurrency/Print in Order.java
index a23042a0..f9de39ff 100644
--- a/Concurrency/Print in Order.java	
+++ b/Concurrency/Print in Order.java	
@@ -1,53 +1,44 @@
+import java.util.concurrent.atomic.AtomicInteger;
+
 class Foo {
-    
-    private int counter = 1;
-    private String mutex = "";
-    public Foo() {
-        
-    }
 
-    public void first(Runnable printFirst) throws InterruptedException {
-        
-        // printFirst.run() outputs "first". Do not change or remove this line.
-        boolean flag = true;
-        while (flag) {
-            synchronized(mutex) {
-                if (counter == 1) {
-                    printFirst.run();
-                    counter++;
-                    flag = false;
-                }
-            }
-        }
+  private Object lock;
+  private AtomicInteger counter;
+
+  public Foo() {
+    this.lock = new Object();
+    this.counter = new AtomicInteger(0);
+  }
+
+  public void first(Runnable printFirst) throws InterruptedException {
+
+    // printFirst.run() outputs "first". Do not change or remove this line.
+    synchronized (lock) {
+      printFirst.run();
+      this.counter.incrementAndGet();
+      this.lock.notifyAll();
     }
+  }
 
-    public void second(Runnable printSecond) throws InterruptedException {
-        
-        // printSecond.run() outputs "second". Do not change or remove this line.
-        boolean flag = true;
-        while (flag) {
-            synchronized(mutex) {
-                if (counter == 2) {
-                    printSecond.run();
-                    counter++;
-                    flag = false;
-                }
-            }
-        }
+  public void second(Runnable printSecond) throws InterruptedException {
+    // printSecond.run() outputs "second". Do not change or remove this line.
+    synchronized (lock) {
+      while (this.counter.get() != 1) {
+        this.lock.wait();
+      }
+      printSecond.run();
+      this.counter.incrementAndGet();
+      this.lock.notifyAll();
     }
+  }
 
-    public void third(Runnable printThird) throws InterruptedException {
-        
-        // printThird.run() outputs "third". Do not change or remove this line.
-        boolean flag = true;
-        while (flag) {
-            synchronized(mutex) {
-                if (counter == 3) {
-                    printThird.run();
-                    counter++;
-                    flag = false;
-                }
-            }
-        }
+  public void third(Runnable printThird) throws InterruptedException {
+    // printThird.run() outputs "third". Do not change or remove this line.
+    synchronized (lock) {
+      while (this.counter.get() != 2) {
+        this.lock.wait();
+      }
+      printThird.run();
     }
+  }
 }

From 43446fd0e060c811bc505022e658b66d1c1d0983 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Feb 2022 16:18:23 -0800
Subject: [PATCH 0764/2175] Update Meeting Scheduler.java

---
 Medium/Meeting Scheduler.java | 35 +++++++++++------------------------
 1 file changed, 11 insertions(+), 24 deletions(-)

diff --git a/Medium/Meeting Scheduler.java b/Medium/Meeting Scheduler.java
index 42f7b044..d5bf6b16 100644
--- a/Medium/Meeting Scheduler.java	
+++ b/Medium/Meeting Scheduler.java	
@@ -1,34 +1,21 @@
 class Solution {
   public List<Integer> minAvailableDuration(int[][] slots1, int[][] slots2, int duration) {
-    int idx1 = 0;
-    int idx2 = 0;
-    Arrays.sort(slots1, new sortByStartAndEndTime());
-    Arrays.sort(slots2, new sortByStartAndEndTime());
-    while (idx1 < slots1.length && idx2 < slots2.length) {
-      int maxStart = Math.max(slots1[idx1][0], slots2[idx2][0]);
-      int minEnd = Math.min(slots1[idx1][1], slots2[idx2][1]);
+    Arrays.sort(slots1, Comparator.comparingInt(o -> o[0]));
+    Arrays.sort(slots2, Comparator.comparingInt(o -> o[0]));
+    int idxOne = 0;
+    int idxTwo = 0;
+    while (idxOne < slots1.length && idxTwo < slots2.length) {
+      int maxStart = Math.max(slots1[idxOne][0], slots2[idxTwo][0]);
+      int minEnd = Math.min(slots1[idxOne][1], slots2[idxTwo][1]);
       if (minEnd - maxStart >= duration) {
         return Arrays.asList(maxStart, maxStart + duration);
       }
-      if (slots1[idx1][1] < slots2[idx2][1]) {
-        idx1++;
-      }
-      else {
-        idx2++;
+      if (slots1[idxOne][1] > slots2[idxTwo][1]) {
+        idxTwo++;
+      } else {
+        idxOne++;
       }
     }
     return new ArrayList<>();
   }
-
-  class sortByStartAndEndTime implements Comparator<int[]> {
-
-    @Override
-    public int compare(int[] o1, int[] o2) {
-      int c = o1[0] - o2[0];
-      if (c != 0) {
-        return c;
-      }
-      return o1[1] - o2[1];
-    }
-  }
 }

From 592ad0e375127f688867b2fc637e615fe6a22bb5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Feb 2022 07:25:43 -0800
Subject: [PATCH 0765/2175] Update Top K Frequent Elements.java

---
 Medium/Top K Frequent Elements.java | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/Medium/Top K Frequent Elements.java b/Medium/Top K Frequent Elements.java
index f3f6ae2d..ffb13529 100644
--- a/Medium/Top K Frequent Elements.java	
+++ b/Medium/Top K Frequent Elements.java	
@@ -4,21 +4,22 @@ public int[] topKFrequent(int[] nums, int k) {
     for (int num : nums) {
       map.put(num, map.getOrDefault(num, 0) + 1);
     }
-    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
-      public int compare(Integer p1, Integer p2) {
-        return map.get(p1) - map.get(p2);
-      }
-    });
+    Map<Integer, List<Integer>> frequencyToValueMap = new HashMap<>();
     for (Integer key : map.keySet()) {
-      pq.add(key);
-      if (pq.size() > k) {
-        pq.poll();
-      }
+      frequencyToValueMap.computeIfAbsent(map.get(key), j -> new ArrayList<>()).add(key);
     }
-    int[] ans = new int[k];
-    for (int i = 0; i < k; i++) {
-      ans[i] = pq.poll();
+    List<Integer> result = new ArrayList<>();
+    for (int i = nums.length; i >= 0 && result.size() < k; i--) {
+      List<Integer> values = frequencyToValueMap.getOrDefault(i, new ArrayList<>());
+      if (result.size() + values.size() <= k) {
+        result.addAll(values);
+      } else {
+        int idx = 0;
+        while (result.size() < k) {
+          result.add(values.get(idx++));
+        }
+      }
     }
-    return ans;
+    return result.stream().mapToInt(i -> i).toArray();
   }
 }

From 91b7257d33433eb480bc057ed86c8e36779c61ed Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Feb 2022 07:35:00 -0800
Subject: [PATCH 0766/2175] Update Permutation in String.java

---
 Medium/Permutation in String.java | 33 +++++++++++++++++++------------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/Medium/Permutation in String.java b/Medium/Permutation in String.java
index e405a988..ff95424e 100644
--- a/Medium/Permutation in String.java	
+++ b/Medium/Permutation in String.java	
@@ -1,25 +1,32 @@
 class Solution {
   public boolean checkInclusion(String s1, String s2) {
-    if (s1.length() > s2.length()) {
+    if (s2.length() < s1.length()) {
       return false;
     }
-    int[] counter = new int[26];
-    for (char c : s1.toCharArray()) {
-      counter[c - 'a']++;
+    int[] frequency = new int[26];
+    for (int i = 0; i < s1.length(); i++) {
+      frequency[s1.charAt(i) - 'a']++;
+      frequency[s2.charAt(i) - 'a']--;
     }
-    String targetStr = Arrays.toString(counter);
-    int[] targetCounter = new int[26];
-    for (int i = 0; i < s1.length() - 1; i++) {
-      targetCounter[s2.charAt(i) - 'a']++;
+    if (allZeroArray(frequency)) {
+      return true;
     }
-    int start = 0;
-    for (int i = s1.length() - 1; i < s2.length(); i++) {
-      targetCounter[s2.charAt(i) - 'a']++;
-      if (Arrays.toString(targetCounter).equals(targetStr)) {
+    for (int i = s1.length(); i < s2.length(); i++) {
+      frequency[s2.charAt(i) - 'a']--;
+      frequency[s2.charAt(i - s1.length()) - 'a']++;
+      if (allZeroArray(frequency)) {
         return true;
       }
-      targetCounter[s2.charAt(start++) - 'a']--;
     }
     return false;
   }
+
+  private boolean allZeroArray(int[] frequency) {
+    for (int count : frequency) {
+      if (count != 0) {
+        return false;
+      }
+    }
+    return true;
+  }
 }

From 6ef27f17bc731542e5eb4ced06ddd4d3061620fb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Feb 2022 14:19:12 -0800
Subject: [PATCH 0767/2175] Update Coin Change.java

---
 Medium/Coin Change.java | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/Medium/Coin Change.java b/Medium/Coin Change.java
index e5bfb1f1..adfc9082 100644
--- a/Medium/Coin Change.java	
+++ b/Medium/Coin Change.java	
@@ -1,29 +1,28 @@
 class Solution {
   public int coinChange(int[] coins, int amount) {
-    if (amount < 1) {
-      return 0;
-    }
-    return coinChange(coins, amount, new int[amount]);
+    Integer[] memo = new Integer[amount + 1];
+    return coinChangeMemoization(coins, amount, memo);
   }
-  
-  private int coinChange(int[] coins, int amount, int[] memo) {
+
+  private int coinChangeMemoization(int[] coins, int amount, Integer[] memo) {
     if (amount < 0) {
       return -1;
     }
     if (amount == 0) {
       return 0;
     }
-    if (memo[amount - 1] != 0) {
-      return memo[amount - 1];
+    if (memo[amount] != null) {
+      return memo[amount];
     }
-    int min = Integer.MAX_VALUE;
+    int minCount = Integer.MAX_VALUE;
     for (int coin : coins) {
-      int res = coinChange(coins, amount - coin, memo);
-      if (res >= 0 && res < min) {
-        min = 1 + res;
+      int count = coinChangeMemoization(coins, amount - coin, memo);
+      if (count == -1) {
+        continue;
       }
+      minCount = Math.min(minCount, count + 1);
     }
-    memo[amount - 1] = min == Integer.MAX_VALUE ? -1 : min;
-    return memo[amount - 1];
+    memo[amount] = minCount == Integer.MAX_VALUE ? -1 : minCount;
+    return memo[amount];
   }
 }

From a512165edf5c95be3c44f83e52f434112201e0f7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Feb 2022 14:24:53 -0800
Subject: [PATCH 0768/2175] Update Coin Change.java

---
 Medium/Coin Change.java | 33 +++++++++++++++++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/Medium/Coin Change.java b/Medium/Coin Change.java
index adfc9082..f728e957 100644
--- a/Medium/Coin Change.java	
+++ b/Medium/Coin Change.java	
@@ -1,7 +1,17 @@
 class Solution {
   public int coinChange(int[] coins, int amount) {
-    Integer[] memo = new Integer[amount + 1];
-    return coinChangeMemoization(coins, amount, memo);
+    Integer[] dp = new Integer[amount + 1];
+    Arrays.fill(dp, amount + 1);
+    dp[0] = 0;
+    for (int i = 1; i <= amount; i++) {
+      for (int coin : coins) {
+        if (i - coin < 0) {
+          continue;
+        }
+        dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+      }
+    }
+    return dp[amount] == (amount + 1) ? -1 : dp[amount];
   }
 
   private int coinChangeMemoization(int[] coins, int amount, Integer[] memo) {
@@ -25,4 +35,23 @@ private int coinChangeMemoization(int[] coins, int amount, Integer[] memo) {
     memo[amount] = minCount == Integer.MAX_VALUE ? -1 : minCount;
     return memo[amount];
   }
+  
+  // This approach times out due to overlapping subproblems
+  private int coinChangeRecursive(int[] coins, int amount) {
+    if (amount < 0) {
+      return -1;
+    }
+    if (amount == 0) {
+      return 0;
+    }
+    int minCount = Integer.MAX_VALUE;
+    for (int coin : coins) {
+      int count = coinChangeRecursive(coins, amount - coin);
+      if (count == -1) {
+        continue;
+      }
+      minCount = Math.min(minCount, count);
+    }
+    return minCount == Integer.MAX_VALUE ? -1 : minCount;
+  }
 }

From c029de1ce38eaf1e51f2be461bd447b4729b6c46 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Feb 2022 20:08:47 -0800
Subject: [PATCH 0769/2175] Update Subsets.java

---
 Medium/Subsets.java | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/Medium/Subsets.java b/Medium/Subsets.java
index e86ccecd..3e0aba4d 100644
--- a/Medium/Subsets.java
+++ b/Medium/Subsets.java
@@ -1,19 +1,20 @@
 class Solution {
   public List<List<Integer>> subsets(int[] nums) {
-    List<List<Integer>> list = new ArrayList<>();
-    helper(nums, list, new ArrayList<>(), 0);
-    return list;
+    List<List<Integer>> result = new ArrayList<>();
+    helper(nums, 0, new ArrayList<>(), result);
+    return new ArrayList<>(result);
   }
-  
-  private void helper(int[] nums, List<List<Integer>> list, List<Integer> curr, int idx) {
-    list.add(new ArrayList<>(curr));
-    if (idx >= nums.length) {
+
+  private void helper(int[] nums, int currIdx, List<Integer> currSubset,
+      List<List<Integer>> result) {
+    result.add(new ArrayList<>(currSubset));
+    if (currIdx >= nums.length) {
       return;
     }
-    for (int i = idx; i < nums.length; i++) {
-      curr.add(nums[i]);
-      helper(nums, list, curr, i + 1);
-      curr.remove(curr.size() - 1);
+    for (int i = currIdx; i < nums.length; i++) {
+      currSubset.add(nums[i]);
+      helper(nums, i + 1, currSubset, result);
+      currSubset.remove(currSubset.size() - 1);
     }
   }
 }

From ba0078636559a47de72525f9f097d654bb9be30f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Feb 2022 06:41:48 -0800
Subject: [PATCH 0770/2175] Create Count Operations to Obtain Zero.java

---
 Easy/Count Operations to Obtain Zero.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Count Operations to Obtain Zero.java

diff --git a/Easy/Count Operations to Obtain Zero.java b/Easy/Count Operations to Obtain Zero.java
new file mode 100644
index 00000000..7f1678c6
--- /dev/null
+++ b/Easy/Count Operations to Obtain Zero.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int countOperations(int num1, int num2) {
+    int numOfOperations = 0;
+    while (num1 != 0 && num2 != 0) {
+      if (num1 >= num2) {
+        num1 -= num2;
+      } else {
+        num2 -= num1;
+      }
+      numOfOperations++;
+    }
+    return numOfOperations;
+  }
+}

From 9cd6fbeb1b6ab7d0a8a66bbc3d328632f4cb39fe Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Feb 2022 14:32:14 -0800
Subject: [PATCH 0771/2175] Update Design A Leaderboard.java

---
 Medium/Design A Leaderboard.java | 64 +++++++++++++++++---------------
 1 file changed, 34 insertions(+), 30 deletions(-)

diff --git a/Medium/Design A Leaderboard.java b/Medium/Design A Leaderboard.java
index 9a5ca751..8ae6740f 100644
--- a/Medium/Design A Leaderboard.java	
+++ b/Medium/Design A Leaderboard.java	
@@ -1,39 +1,43 @@
 class Leaderboard {
-    Map<Integer, Integer> scoreMap;
-    Map<Integer, Set<Integer>> playerMap;
-    public Leaderboard() {
-        scoreMap = new HashMap<>();
-        playerMap = new TreeMap<>(Collections.reverseOrder());
-    }
 
-    public void addScore(int playerId, int score) {
-        if (scoreMap.containsKey(playerId)) {
-            int prevScore = scoreMap.get(playerId);
-            playerMap.get(prevScore).remove(playerId);
-        }
-        scoreMap.put(playerId, scoreMap.getOrDefault(playerId, 0) + score);
-        playerMap.computeIfAbsent(scoreMap.get(playerId), k -> new HashSet<>()).add(playerId);
-    }
+  private Map<Integer, Integer> playerToScoreMapping;
+  private Map<Integer, Set<Integer>> scoreToPlayerMapping;
 
-    public int top(int K) {
-        int sum = 0;
-        for (Integer key : playerMap.keySet()) {
-            int count = Math.min(K, playerMap.get(key).size());
-            sum += key * count;
-            K -= count;
-            if (K == 0) {
-                break;
-            }
-        }
-        return sum;
+  public Leaderboard() {
+    this.playerToScoreMapping = new HashMap<>();
+    this.scoreToPlayerMapping = new TreeMap<>(Collections.reverseOrder());
+  }
+
+  public void addScore(int playerId, int score) {
+    if (playerToScoreMapping.containsKey(playerId)) {
+      int previousScore = playerToScoreMapping.get(playerId);
+      if (scoreToPlayerMapping.getOrDefault(previousScore, new HashSet<>()).contains(playerId)) {
+        scoreToPlayerMapping.get(previousScore).remove(playerId);
+      }
+      score += previousScore;
     }
+    playerToScoreMapping.put(playerId, score);
+    scoreToPlayerMapping.computeIfAbsent(score, k -> new HashSet<>()).add(playerId);
+  }
 
-    public void reset(int playerId) {
-        int prevScore = scoreMap.get(playerId);
-        playerMap.get(prevScore).remove(playerId);
-        scoreMap.put(playerId, 0);
-        playerMap.computeIfAbsent(0, k -> new HashSet<>()).add(playerId);
+  public int top(int K) {
+    int totalScore = 0;
+    for (Integer currScore : scoreToPlayerMapping.keySet()) {
+      int totalPlayersWithScore = scoreToPlayerMapping.get(currScore).size();
+      int playersRemaining = Math.min(K, totalPlayersWithScore);
+      totalScore += playersRemaining * currScore;
+      K -= playersRemaining;
+      if (K == 0) {
+        break;
+      }
     }
+    return totalScore;
+  }
+
+  public void reset(int playerId) {
+    scoreToPlayerMapping.get(playerToScoreMapping.get(playerId)).remove(playerId);
+    playerToScoreMapping.put(playerId, 0);
+  }
 }
 
 /**

From 0cd3a9549c0392671d70d7fd9c6d221e478a5548 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Feb 2022 14:54:12 -0800
Subject: [PATCH 0772/2175] Update and rename Hard/Longest Substring with At
 Most Two Distinct Characters.java to Medium/Longest Substring with At Most
 Two Distinct Characters.java

---
 ... with At Most Two Distinct Characters.java | 27 -------------------
 ... with At Most Two Distinct Characters.java | 22 +++++++++++++++
 2 files changed, 22 insertions(+), 27 deletions(-)
 delete mode 100644 Hard/Longest Substring with At Most Two Distinct Characters.java
 create mode 100644 Medium/Longest Substring with At Most Two Distinct Characters.java

diff --git a/Hard/Longest Substring with At Most Two Distinct Characters.java b/Hard/Longest Substring with At Most Two Distinct Characters.java
deleted file mode 100644
index deb1b3d7..00000000
--- a/Hard/Longest Substring with At Most Two Distinct Characters.java	
+++ /dev/null
@@ -1,27 +0,0 @@
-class Solution {
-    public int lengthOfLongestSubstringTwoDistinct(String s) {
-        Map<Character, Integer> map = new HashMap<>();
-        int slow = 0;
-        int fast = 0;
-        int maxLen = 0;
-        int n = s.length();
-        
-        while (fast < n) {
-            map.put(s.charAt(fast), map.getOrDefault(s.charAt(fast), 0) + 1);
-            
-            while (map.size() > 2) {
-                map.put(s.charAt(slow), map.getOrDefault(s.charAt(slow), 0) - 1);
-                if (map.get(s.charAt(slow)) <= 0) {
-                    map.remove(s.charAt(slow));
-                }
-                
-                slow++;
-            }
-            
-            fast++;
-            maxLen = Math.max(maxLen, fast - slow);
-        }
-        
-        return maxLen;
-    }
-}
diff --git a/Medium/Longest Substring with At Most Two Distinct Characters.java b/Medium/Longest Substring with At Most Two Distinct Characters.java
new file mode 100644
index 00000000..2af3a613
--- /dev/null
+++ b/Medium/Longest Substring with At Most Two Distinct Characters.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int lengthOfLongestSubstringTwoDistinct(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    int startIdx = 0;
+    int endIdx = 0;
+    int n = s.length();
+    int maxLength = 0;
+    while (endIdx < n) {
+      map.put(s.charAt(endIdx), map.getOrDefault(s.charAt(endIdx), 0) + 1);
+      while (startIdx < endIdx && map.size() > 2) {
+        map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0) - 1);
+        if (map.get(s.charAt(startIdx)) <= 0) {
+          map.remove(s.charAt(startIdx));
+        }
+        startIdx++;
+      }
+      endIdx++;
+      maxLength = Math.max(endIdx - startIdx, maxLength);
+    }
+    return maxLength;
+  }
+}

From 8b7a5edb95b8132c9212e3d5e6b94930b00c317f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Feb 2022 21:25:36 -0800
Subject: [PATCH 0773/2175] Update Maximum depth of Binary tree.java

---
 Easy/Maximum depth of Binary tree.java | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/Easy/Maximum depth of Binary tree.java b/Easy/Maximum depth of Binary tree.java
index 98bfb842..8661d52e 100644
--- a/Easy/Maximum depth of Binary tree.java	
+++ b/Easy/Maximum depth of Binary tree.java	
@@ -4,14 +4,20 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int maxDepth(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
+  public int maxDepth(TreeNode root) {
+    if (root == null) {
+      return 0;
     }
+    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
+  }
 }

From effd03f3c96b65b79a157f528e7096dda1a2ab79 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 14 Feb 2022 10:43:50 -0800
Subject: [PATCH 0774/2175] Update Network Delay Time.java

---
 Medium/Network Delay Time.java | 65 +++++++++++++---------------------
 1 file changed, 24 insertions(+), 41 deletions(-)

diff --git a/Medium/Network Delay Time.java b/Medium/Network Delay Time.java
index d1dc03be..90ddb22c 100644
--- a/Medium/Network Delay Time.java	
+++ b/Medium/Network Delay Time.java	
@@ -1,49 +1,32 @@
 class Solution {
-  public int networkDelayTime(int[][] times, int N, int K) {
-    Map<Integer, List<Connection>> map = new HashMap<>();
+  public int networkDelayTime(int[][] times, int n, int k) {
+    // Mapping from node to all outgoing edges alongside weight of each edge
+    Map<Integer, List<int[]>> map = new HashMap<>();
     for (int[] time : times) {
-      map.computeIfAbsent(time[0], k -> new ArrayList<>()).add(new Connection(time[1], time[2]));
+      map.computeIfAbsent(time[0], j -> new ArrayList<>()).add(new int[] {time[1], time[2]});
     }
-    Map<Integer, Integer> dist = new HashMap<>();
-    for (int node = 1; node <= N; node++) {
-      dist.put(node, Integer.MAX_VALUE);
-    }
-    dist.put(K, 0);
-    boolean[] seen = new boolean[N + 1];
-    while (true) {
-      int candNode = -1;
-      int candDist = Integer.MAX_VALUE;
-      for (int i = 1; i <= N; ++i) {
-        if (!seen[i] && dist.get(i) < candDist) {
-          candDist = dist.get(i);
-          candNode = i;
-        }
-      }
-      if (candNode < 0) {
-        break;
-      }
-      seen[candNode] = true;
-      for (Connection con: map.getOrDefault(candNode, new ArrayList<>())) {
-        dist.put(con.val, Math.min(dist.get(con.val), dist.get(candNode) + con.time));
+    // Min heap in order of edge weight
+    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(o -> o[0]));
+    priorityQueue.add(new int[] {0, k});
+    Set<Integer> visited = new HashSet<>();
+    int totalTime = 0;
+    while (!priorityQueue.isEmpty()) {
+      int[] removed = priorityQueue.poll();
+      int currNode = removed[1];
+      int edgeWeight = removed[0];
+      if (visited.contains(currNode)) {
+        continue;
       }
-    }
-    int ans = 0;
-    for (int cand: dist.values()) {
-      if (cand == Integer.MAX_VALUE) {
-        return -1;
+      visited.add(currNode);
+      totalTime = Math.max(totalTime, edgeWeight);
+      for (int[] neighbor : map.getOrDefault(removed[1], new ArrayList<>())) {
+        int neighborNode = neighbor[0];
+        int neighborEdgeWeight = neighbor[1];
+        if (!visited.contains(neighborNode)) {
+          priorityQueue.add(new int[] {neighborEdgeWeight + edgeWeight, neighborNode});
+        }
       }
-      ans = Math.max(ans, cand);
     }
-    return ans;
-  }
-}
-
-class Connection {
-  int val;
-  int time;
-  
-  public Connection(int val, int time) {
-    this.val = val;
-    this.time = time;
+    return visited.size() == n ? totalTime : -1;
   }
 }

From c81691fc16898f24c416aa3d87b7df1b9dd68bc8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 14 Feb 2022 11:23:27 -0800
Subject: [PATCH 0775/2175] Update One Edit Distance.java

---
 Medium/One Edit Distance.java | 79 +++++++++++++++--------------------
 1 file changed, 34 insertions(+), 45 deletions(-)

diff --git a/Medium/One Edit Distance.java b/Medium/One Edit Distance.java
index 7a78e333..dc32eede 100644
--- a/Medium/One Edit Distance.java	
+++ b/Medium/One Edit Distance.java	
@@ -1,50 +1,39 @@
 class Solution {
-    public static boolean isOneEditDistance(String s, String t) {
-        if (Math.abs(s.length() - t.length()) > 1) {
-            return false;
-        }
-        else if (s.length() - t.length() == 0) {
-            if (s.equals(t)) {
-                return false;
-            }
-
-            boolean missed = false;
-            for (int i=0; i<s.length(); i++) {
-                if (s.charAt(i) == t.charAt(i)) {
-                    continue;
-                }
-                if (missed) {
-                    return false;
-                }
-                
-                missed = true;
-            }
-            return true;
-        }
-
-        return s.length() - t.length() == 1 ? oneDeleteOnly(s,t) : oneDeleteOnly(t,s);
+  public boolean isOneEditDistance(String s, String t) {
+    int lengthDiff = Math.abs(s.length() - t.length());
+    if (s.equals(t) || lengthDiff > 1) {
+      return false;
     }
-
-    private static boolean oneDeleteOnly(String s, String t) {
-        if (t.length() == 0) {
-            return true;
-        }
-        int i = 0;
-        int j = 0;
-
-        while (i < s.length() && j < t.length()) {
-            if (s.charAt(i) != t.charAt(j)) {
-                if (i > j) {
-                    return false;
-                }
-                i++;
-                continue;
-            }
-
-            i++;
-            j++;
+    if (s.length() == 0 || t.length() == 0) {
+      return true;
+    }
+    int idxOne = 0;
+    int idxTwo = 0;
+    boolean changeDone = false;
+    while (idxOne < s.length() && idxTwo < t.length()) {
+      if (s.charAt(idxOne) == t.charAt(idxTwo)) {
+        idxOne++;
+        idxTwo++;
+        continue;
+      }
+      if (changeDone) {
+        return false;
+      }
+      if (lengthDiff != 0) {
+        if (s.length() > t.length()) {
+          idxOne++;
+        } else {
+          idxTwo++;
         }
-
-        return true;
+      } else {
+        idxOne++;
+        idxTwo++;
+      }
+      changeDone = true;
+    }
+    if (changeDone && (idxOne != s.length() || idxTwo != t.length())) {
+      return false;
     }
+    return true;
+  }
 }

From 218ea4f8ff268b1fb679e2c08a837ba1231d03a5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 14 Feb 2022 15:57:16 -0800
Subject: [PATCH 0776/2175] Update Meeting Rooms.java

---
 Easy/Meeting Rooms.java | 35 ++++++++---------------------------
 1 file changed, 8 insertions(+), 27 deletions(-)

diff --git a/Easy/Meeting Rooms.java b/Easy/Meeting Rooms.java
index 5b3b806c..53af36c7 100644
--- a/Easy/Meeting Rooms.java	
+++ b/Easy/Meeting Rooms.java	
@@ -1,30 +1,11 @@
-/**
- * Definition for an interval.
- * public class Interval {
- *     int start;
- *     int end;
- *     Interval() { start = 0; end = 0; }
- *     Interval(int s, int e) { start = s; end = e; }
- * }
- */
 class Solution {
-    public static boolean canAttendMeetings(Interval[] intervals) {
-        Arrays.sort(intervals, new Comparator<Interval>() {
-            @Override
-            public int compare(Interval o1, Interval o2) {
-                return o1.start - o2.start;
-            }
-        });
-
-        int i=0;
-        while (i < intervals.length - 1) {
-            if (intervals[i].end > intervals[i+1].start) {
-                return false;
-            }
-
-            i++;
-        }
-
-        return true;
+  public boolean canAttendMeetings(int[][] intervals) {
+    Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0]));
+    for (int i = 1; i < intervals.length; i++) {
+      if (intervals[i][0] < intervals[i - 1][1]) {
+        return false;
+      }
     }
+    return true;
+  }
 }

From 81c6d7f0be1cd28a51007e39741df3ceb9ec6a3c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 14 Feb 2022 16:01:57 -0800
Subject: [PATCH 0777/2175] Update Meeting Rooms II.java

---
 Medium/Meeting Rooms II.java | 33 ++++++++++-----------------------
 1 file changed, 10 insertions(+), 23 deletions(-)

diff --git a/Medium/Meeting Rooms II.java b/Medium/Meeting Rooms II.java
index e327a24a..d43eab4e 100644
--- a/Medium/Meeting Rooms II.java	
+++ b/Medium/Meeting Rooms II.java	
@@ -1,29 +1,16 @@
 class Solution {
   public int minMeetingRooms(int[][] intervals) {
-    Arrays.sort(intervals, new Comparator<int[]>() {
-      @Override
-      public int compare(int[] o1, int[] o2) {
-        int c = o1[0] - o2[0];
-        if (c != 0) {
-          return c;
-        }
-        return o1[1] - o2[1];
+    Arrays.sort(intervals, Comparator.comparingInt((a) -> a[0]));
+    PriorityQueue<int[]> meetingsInProgress = new PriorityQueue<>(
+        Comparator.comparingInt((a) -> a[1]));
+    int result = 0;
+    for (int[] interval : intervals) {
+      while (!meetingsInProgress.isEmpty() && meetingsInProgress.peek()[1] <= interval[0]) {
+        meetingsInProgress.poll();
       }
-    });
-    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
-      @Override
-      public int compare(int[] o1, int[] o2) {
-        return o1[1] - o2[1];
-      }
-    });
-    int maxCount = 0;
-    for (int i = 0; i < intervals.length; i++) {
-      while (!pq.isEmpty() && pq.peek()[1] <= intervals[i][0]) {
-        pq.poll();
-      }
-      pq.add(intervals[i]);
-      maxCount = Math.max(maxCount, pq.size());
+      meetingsInProgress.add(interval);
+      result = Math.max(result, meetingsInProgress.size());
     }
-    return maxCount;
+    return result;
   }
 }

From 0d7374d54e90497ed06969e1097bb9ae8273b5f8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 14 Feb 2022 16:06:00 -0800
Subject: [PATCH 0778/2175] Update Single Number.java

---
 Easy/Single Number.java | 31 ++++++++-----------------------
 1 file changed, 8 insertions(+), 23 deletions(-)

diff --git a/Easy/Single Number.java b/Easy/Single Number.java
index 94568349..9c1601e9 100644
--- a/Easy/Single Number.java	
+++ b/Easy/Single Number.java	
@@ -1,24 +1,9 @@
-public class Solution {
-    public int singleNumber(int[] nums) {
-        if (nums.length == 1) return nums[0];
-        Arrays.sort(nums);
-        if (nums[0] != nums[1]) {
-            return nums[0];
-        }
-        boolean twice = true;
-        for (int i=0;i<nums.length-1;i++) {
-            if (nums[i] != nums[i+1]) {
-                if (twice) {
-                    twice = false;
-                }
-                else {
-                    return nums[i];
-                }
-            }
-            else {
-                twice = true;
-            }
-        }
-        return nums[nums.length-1];
+class Solution {
+  public int singleNumber(int[] nums) {
+    int xor = nums[0];
+    for (int i = 1; i < nums.length; i++) {
+      xor ^= nums[i];
     }
-}
\ No newline at end of file
+    return xor;
+  }
+}

From 6521b3943e312a565f03d808aeb799d85c44b8eb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Feb 2022 06:39:31 -0800
Subject: [PATCH 0779/2175] Update Flatten 2D Vector.java

---
 Medium/Flatten 2D Vector.java | 43 ++++++++++++++++++++---------------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/Medium/Flatten 2D Vector.java b/Medium/Flatten 2D Vector.java
index c9c0ce8c..d6b9b9d7 100644
--- a/Medium/Flatten 2D Vector.java	
+++ b/Medium/Flatten 2D Vector.java	
@@ -1,33 +1,40 @@
 class Vector2D {
-  int vectorIdx;
-  int currIdx;
-  int[][] v;
-  public Vector2D(int[][] v) {
-    vectorIdx = 0;
-    currIdx = 0;
-    this.v = v;
+
+  private int[][] vec;
+  private int vecIdx;
+  private int idx;
+
+  public Vector2D(int[][] vec) {
+    this.vec = vec;
+    this.idx = 0;
+    this.vecIdx = 0;
+    updateIdx();
+  }
+
+  private void updateIdx() {
+    if (this.vecIdx < this.vec.length && this.idx == this.vec[this.vecIdx].length) {
+      this.idx = 0;
+      this.vecIdx++;
+    }
+    while (this.vecIdx < this.vec.length && this.vec[this.vecIdx].length == 0) {
+      this.vecIdx++;
+    }
   }
 
   public int next() {
-    hasNext();
-    return v[vectorIdx][currIdx++];
+    int result = this.vec[this.vecIdx][this.idx++];
+    updateIdx();
+    return result;
   }
 
   public boolean hasNext() {
-    while (vectorIdx < v.length) {
-      if (currIdx < v[vectorIdx].length) {
-        return true;
-      }
-      vectorIdx++;
-      currIdx = 0;
-    }
-    return false;
+    return this.vecIdx < this.vec.length;
   }
 }
 
 /**
  * Your Vector2D object will be instantiated and called as such:
- * Vector2D obj = new Vector2D(v);
+ * Vector2D obj = new Vector2D(vec);
  * int param_1 = obj.next();
  * boolean param_2 = obj.hasNext();
  */

From 29fbe98b5124eddda7fba6cc19cf46ae731330b2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Feb 2022 07:59:37 -0800
Subject: [PATCH 0780/2175] Update Find K-Length Substrings With No Repeated
 Characters.java

---
 ...ubstrings With No Repeated Characters.java | 44 +++++++++----------
 1 file changed, 21 insertions(+), 23 deletions(-)

diff --git a/Medium/Find K-Length Substrings With No Repeated Characters.java b/Medium/Find K-Length Substrings With No Repeated Characters.java
index 5c435fbf..fee2952d 100644
--- a/Medium/Find K-Length Substrings With No Repeated Characters.java	
+++ b/Medium/Find K-Length Substrings With No Repeated Characters.java	
@@ -1,26 +1,24 @@
 class Solution {
-    public int numKLenSubstrNoRepeats(String S, int K) {
-        int count = 0;
-        int start = 0;
-        Map<Character, Integer> map = new HashMap<>();
-        for (int i = 0; i < K - 1 && i < S.length(); i++) {
-            map.put(S.charAt(i), map.getOrDefault(S.charAt(i), 0) + 1);
-        }
-
-        for (int i = K - 1; i < S.length(); i++) {
-            map.put(S.charAt(i), map.getOrDefault(S.charAt(i), 0) + 1);
-            if (map.size() == K) {
-                count++;
-            }
-
-            map.put(S.charAt(start), map.get(S.charAt(start)) - 1);
-            if (map.get(S.charAt(start)) == 0) {
-                map.remove(S.charAt(start));
-            }
-
-            start++;
-        }
-
-        return count;
+  public int numKLenSubstrNoRepeats(String s, int k) {
+    if (s.length() < k) {
+      return 0;
     }
+    Map<Character, Integer> map = new HashMap<>();
+    for (int i = 0; i < k; i++) {
+      map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
+    }
+    int resultCount = 0;
+    for (int i = k; i < s.length(); i++) {
+      if (map.size() == k) {
+        resultCount++;
+      }
+      int startIdx = i - k;
+      map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0) - 1);
+      if (map.get(s.charAt(startIdx)) == 0) {
+        map.remove(s.charAt(startIdx));
+      }
+      map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
+    }
+    return resultCount + (map.size() == k ? 1 : 0);
+  }
 }

From 14a3a640c406a422689aed6d2aeb4151c5738ff1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Feb 2022 08:46:24 -0800
Subject: [PATCH 0781/2175] Update Inorder Successor in BST.java

---
 Medium/Inorder Successor in BST.java | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/Medium/Inorder Successor in BST.java b/Medium/Inorder Successor in BST.java
index 62b37697..f7fb5702 100644
--- a/Medium/Inorder Successor in BST.java	
+++ b/Medium/Inorder Successor in BST.java	
@@ -10,24 +10,21 @@
 class Solution {
   public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
     if (p.right != null) {
-      TreeNode node = p.right;
-      while (node.left != null) {
-        node = node.left;
+      TreeNode rightNode = p.right;
+      while (rightNode != null && rightNode.left != null) {
+        rightNode = rightNode.left;
       }
-      return node;
+      return rightNode;
     }
-    else {
-      TreeNode lastLeft = null;
-      while (root != p) {
-        if (root.val > p.val) {
-          lastLeft = root;
-          root = root.left;
-        }
-        else {
-          root = root.right;
-        }
+    TreeNode prev = null;
+    while (root != p) {
+      if (root.val > p.val) {
+        prev = root;
+        root = root.left;
+      } else {
+        root = root.right;
       }
-      return lastLeft;
     }
+    return prev;
   }
 }

From 5d039b180152e0b6c3aba95fa3a032f785126b6c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Feb 2022 11:27:53 -0800
Subject: [PATCH 0782/2175] Update Inorder Successor in BST II.java

---
 Medium/Inorder Successor in BST II.java | 21 +++++++--------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/Medium/Inorder Successor in BST II.java b/Medium/Inorder Successor in BST II.java
index d6810587..e8c672df 100644
--- a/Medium/Inorder Successor in BST II.java	
+++ b/Medium/Inorder Successor in BST II.java	
@@ -10,9 +10,6 @@ class Node {
 
 class Solution {
   public Node inorderSuccessor(Node node) {
-    if (node == null) {
-      return null;
-    }
     if (node.right != null) {
       Node rightNode = node.right;
       while (rightNode.left != null) {
@@ -20,17 +17,13 @@ public Node inorderSuccessor(Node node) {
       }
       return rightNode;
     }
-    else {
-      Node curr = node;
-      Node parentNode = node.parent;
-      while (parentNode != null) {
-        if (parentNode.left == curr) {
-          return parentNode;
-        }
-        curr = parentNode;
-        parentNode = parentNode.parent;
+    while (node.parent != null) {
+      Node parent = node.parent;
+      if (parent.left == node) {
+        return parent;
       }
+      node = parent;
     }
-	return null;
-  }
+    return null;
+  } 
 }

From f16de56d9ebf2e4d9c8556614dc595f773c825e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Feb 2022 15:43:51 -0800
Subject: [PATCH 0783/2175] Update Lowest Common Ancestor of a Binary Tree.java

---
 ...west Common Ancestor of a Binary Tree.java | 23 ++++++++-----------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Medium/Lowest Common Ancestor of a Binary Tree.java b/Medium/Lowest Common Ancestor of a Binary Tree.java
index b83d0663..b49de19a 100644
--- a/Medium/Lowest Common Ancestor of a Binary Tree.java	
+++ b/Medium/Lowest Common Ancestor of a Binary Tree.java	
@@ -8,18 +8,15 @@
  * }
  */
 class Solution {
-    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-        if (root == null || root == p || root == q) {
-            return root;
-        }
-        
-        TreeNode left = lowestCommonAncestor(root.left, p, q);
-        TreeNode right = lowestCommonAncestor(root.right, p, q);
-        
-        if (left != null && right != null) {
-            return root;
-        }
-        
-        return left != null ? left : right;
+  public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null || root == p || root == q) {
+      return root;
     }
+    TreeNode leftRoot = lowestCommonAncestor(root.left, p, q);
+    TreeNode rightRoot = lowestCommonAncestor(root.right, p, q);
+    if (leftRoot != null && rightRoot != null) {
+      return root;
+    }
+    return leftRoot != null ? leftRoot : rightRoot;
+  }
 }

From c67702c98339a448594be7d60c16b48db7dcca22 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Feb 2022 16:03:49 -0800
Subject: [PATCH 0784/2175] Update Kth Largest Element in an Array.java

---
 Medium/Kth Largest Element in an Array.java | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/Medium/Kth Largest Element in an Array.java b/Medium/Kth Largest Element in an Array.java
index eab17f53..1ba91b65 100644
--- a/Medium/Kth Largest Element in an Array.java	
+++ b/Medium/Kth Largest Element in an Array.java	
@@ -1,10 +1,12 @@
 class Solution {
   public int findKthLargest(int[] nums, int k) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> o2 - o1);
-    pq.addAll(Arrays.stream(nums).boxed().collect(Collectors.toList()));
-    while (k-- > 1) {
-      pq.poll();
+    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
+    for (int num : nums) {
+      priorityQueue.add(num);
+      if (priorityQueue.size() > k) {
+        priorityQueue.poll();
+      }
     }
-    return pq.poll();
+    return priorityQueue.peek();
   }
 }

From aade1a1153268690b84fd40efa7dba2ebe78c490 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 16 Feb 2022 14:42:30 -0800
Subject: [PATCH 0785/2175] Update Exclusive Time of Functions.java

---
 Medium/Exclusive Time of Functions.java | 51 ++++++++++++++-----------
 1 file changed, 28 insertions(+), 23 deletions(-)

diff --git a/Medium/Exclusive Time of Functions.java b/Medium/Exclusive Time of Functions.java
index 0138ec69..8212e0c0 100644
--- a/Medium/Exclusive Time of Functions.java	
+++ b/Medium/Exclusive Time of Functions.java	
@@ -1,28 +1,33 @@
 class Solution {
-    public int[] exclusiveTime(int n, List<String> logs) {
-        int[] timer = new int[n];
-        Stack<Integer> stack = new Stack<>();
-        int lastTime = 0;;
-
-        for (String log : logs) {
-            String[] strs = log.split(":");
-            int id = Integer.parseInt(strs[0]);
-            String status = strs[1];
-            int time = Integer.parseInt(strs[2]);
-
-            if (!stack.isEmpty()) {
-                timer[stack.peek()] += time - lastTime;
-            }
-            lastTime = time;
-            if (status.equals("start")) {
-                stack.push(id);
-            }
-            else {
-                timer[stack.pop()]++;
-                lastTime++;
-            }
+  public int[] exclusiveTime(int n, List<String> logs) {
+    int[] result = new int[n];
+    Stack<Log> stack = new Stack<>();
+    for (String log : logs) {
+      Log currentLog = new Log(log);
+      if (currentLog.isStart) {
+        stack.push(currentLog);
+      } else {
+        Log topLog = stack.pop();
+        result[topLog.id] += currentLog.time - topLog.time + 1 - topLog.overLappingTime;
+        if (!stack.isEmpty()) {
+          stack.peek().overLappingTime += currentLog.time - topLog.time + 1;
         }
+      }
+    }
+    return result;
+  }
+
+  private static class Log {
+    public int id;
+    public boolean isStart;
+    public int time;
+    public int overLappingTime;
 
-        return timer;
+    public Log(String log) {
+      String[] split = log.split(":");
+      this.id = Integer.parseInt(split[0]);
+      this.isStart = split[1].equals("start");
+      this.time = Integer.parseInt(split[2]);
     }
+  }
 }

From 7a27f2f316becc7898184e816434a35e0b6fc1f0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 16 Feb 2022 16:06:11 -0800
Subject: [PATCH 0786/2175] Update and rename Medium/Vertical Order Traversal
 Of Binary Tree.java to Hard/Vertical Order Traversal Of a Binary Tree.java

---
 ...ical Order Traversal Of a Binary Tree.java | 56 ++++++++++++++++
 ...rtical Order Traversal Of Binary Tree.java | 67 -------------------
 2 files changed, 56 insertions(+), 67 deletions(-)
 create mode 100644 Hard/Vertical Order Traversal Of a Binary Tree.java
 delete mode 100644 Medium/Vertical Order Traversal Of Binary Tree.java

diff --git a/Hard/Vertical Order Traversal Of a Binary Tree.java b/Hard/Vertical Order Traversal Of a Binary Tree.java
new file mode 100644
index 00000000..8d00094a
--- /dev/null
+++ b/Hard/Vertical Order Traversal Of a Binary Tree.java	
@@ -0,0 +1,56 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public List<List<Integer>> verticalTraversal(TreeNode root) {
+    Map<Integer, List<TreeCoordinate>> map = new TreeMap<>();
+    Queue<TreeCoordinate> queue = new LinkedList<>();
+    queue.add(new TreeCoordinate(root, 0, 0));
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeCoordinate removed = queue.remove();
+        map.computeIfAbsent(removed.y, k -> new ArrayList<>()).add(removed);
+        if (removed.node.left != null) {
+          queue.add(new TreeCoordinate(removed.node.left, removed.x + 1, removed.y - 1));
+        }
+        if (removed.node.right != null) {
+          queue.add(new TreeCoordinate(removed.node.right, removed.x + 1, removed.y + 1));
+        }
+      }
+    }
+    List<List<Integer>> result = new ArrayList<>();
+    for (Integer key : map.keySet()) {
+      List<TreeCoordinate> temp = map.get(key);
+      Collections.sort(temp,
+          Comparator.comparingInt((TreeCoordinate o) -> o.x).thenComparingInt(o -> o.node.val));
+      result.add(temp.stream().map(a -> a.node.val).collect(Collectors.toList()));
+    }
+    return result;
+  }
+  
+  private static class TreeCoordinate {
+    
+    public TreeNode node;
+    public int x;
+    public int y;
+    
+    public TreeCoordinate(TreeNode node, int x, int y) {
+      this.node = node;
+      this.x = x;
+      this.y = y;
+    }
+  }
+}
diff --git a/Medium/Vertical Order Traversal Of Binary Tree.java b/Medium/Vertical Order Traversal Of Binary Tree.java
deleted file mode 100644
index ec9e234f..00000000
--- a/Medium/Vertical Order Traversal Of Binary Tree.java	
+++ /dev/null
@@ -1,67 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode() {}
- *     TreeNode(int val) { this.val = val; }
- *     TreeNode(int val, TreeNode left, TreeNode right) {
- *         this.val = val;
- *         this.left = left;
- *         this.right = right;
- *     }
- * }
- */
-class Solution {
-  public List<List<Integer>> verticalTraversal(TreeNode root) {
-    Comparator<NodePoint> nodePointComparator = (o1, o2) -> {
-      int c = o2.y - o1.y;
-      if (c != 0) {
-        return c;
-      }
-      return o1.node.val - o2.node.val;
-    };
-    Map<Integer, PriorityQueue<NodePoint>> map = new TreeMap<>();
-    Queue<NodePoint> queue = new LinkedList<>();
-    queue.add(new NodePoint(0, 0, root));
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        NodePoint removed = queue.remove();
-        map.computeIfAbsent(
-            removed.x, k -> new PriorityQueue<>(nodePointComparator))
-            .add(removed);
-        if (removed.node.left != null) {
-          queue.add(new NodePoint(removed.x - 1, removed.y - 1, removed.node.left));
-        }
-        if (removed.node.right != null) {
-          queue.add(new NodePoint(removed.x + 1, removed.y - 1, removed.node.right));
-        }
-      }
-    }
-    List<List<Integer>> result = new ArrayList<>();
-    for (Integer key : map.keySet()) {
-      PriorityQueue<NodePoint> pq = map.get(key);
-      List<Integer> temp = new ArrayList<>();
-      while (!pq.isEmpty()) {
-        temp.add(pq.poll().node.val);
-      }
-      result.add(temp);
-    }
-    return result;
-  }
-}
-
-
-class NodePoint {
-  int x;
-  int y;
-  TreeNode node;
-
-  public NodePoint(int x, int y, TreeNode node) {
-    this.x = x;
-    this.y = y;
-    this.node = node;
-  }
-}

From 38d230ec0399fb2c1822fa43cc0fba5e0e16a2d7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 17 Feb 2022 08:51:05 -0800
Subject: [PATCH 0787/2175] Update Combination Sum.java

---
 Medium/Combination Sum.java | 31 ++++++++++++++-----------------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/Medium/Combination Sum.java b/Medium/Combination Sum.java
index 6bd7aa66..de3b3740 100644
--- a/Medium/Combination Sum.java	
+++ b/Medium/Combination Sum.java	
@@ -1,24 +1,21 @@
 class Solution {
   public List<List<Integer>> combinationSum(int[] candidates, int target) {
-    List<List<Integer>> ans = new ArrayList<>();
-    helper(candidates, 0, ans, new ArrayList<>(), target);
-    return ans;
+    List<List<Integer>> result = new ArrayList<>();
+    helper(candidates, 0, target, new ArrayList<>(), result);
+    return result;
   }
-  
-  private void helper(
-    int[] candidates, int idx, List<List<Integer>> ans, List<Integer> list, int target
-  ) {
+
+  private void helper(int[] candidates, int idx, int target, List<Integer> currCombination,
+      List<List<Integer>> result) {
     if (target == 0) {
-      ans.add(new ArrayList<>(list));
-      return;
-    }
-    if (target < 0 || idx == candidates.length) {
-      return;
-    }
-    for (int i = idx; i < candidates.length; i++) {
-      list.add(candidates[i]);
-      helper(candidates, i, ans, list, target - candidates[i]);
-      list.remove(list.size() - 1);
+      result.add(new ArrayList<>(currCombination));
+    } 
+    if (target > 0 && idx < candidates.length) {
+      for (int i = idx; i < candidates.length; i++) {
+        currCombination.add(candidates[i]);
+        helper(candidates, i, target - candidates[i], currCombination, result);
+        currCombination.remove(currCombination.size() - 1);
+      }
     }
   }
 }

From 61186878656aecc9d55558692b79b27911900eeb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 17 Feb 2022 12:03:49 -0800
Subject: [PATCH 0788/2175] Update Binary Tree Right Side View.java

---
 Medium/Binary Tree Right Side View.java | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/Medium/Binary Tree Right Side View.java b/Medium/Binary Tree Right Side View.java
index b75c8784..6aa6e40b 100644
--- a/Medium/Binary Tree Right Side View.java	
+++ b/Medium/Binary Tree Right Side View.java	
@@ -18,26 +18,24 @@ public List<Integer> rightSideView(TreeNode root) {
     if (root == null) {
       return new ArrayList<>();
     }
-    List<Integer> list = new ArrayList<>();
+    List<Integer> result = new ArrayList<>();
     Queue<TreeNode> queue = new LinkedList<>();
     queue.add(root);
     while (!queue.isEmpty()) {
       int size = queue.size();
-      TreeNode rightMost = null;
+      int rightMostValue = -1;
       while (size-- > 0) {
         TreeNode removed = queue.remove();
-        if (rightMost == null) {
-          rightMost = removed;
+        rightMostValue = removed.val;
+        if (removed.left != null) {
+          queue.add(removed.left);
         }
         if (removed.right != null) {
           queue.add(removed.right);
         }
-        if (removed.left != null) {
-          queue.add(removed.left);
-        } 
       }
-      list.add(rightMost.val);
+      result.add(rightMostValue);
     }
-    return list;
+    return result;
   }
 }

From a588b83055e3fb3599921f501fee8337b2b162e7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 17 Feb 2022 12:23:29 -0800
Subject: [PATCH 0789/2175] Create Maximum Swap.java

---
 Medium/Maximum Swap.java | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Maximum Swap.java

diff --git a/Medium/Maximum Swap.java b/Medium/Maximum Swap.java
new file mode 100644
index 00000000..530cbdaa
--- /dev/null
+++ b/Medium/Maximum Swap.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int maximumSwap(int num) {
+    String stringValue = Integer.toString(num);
+    Map<Integer, Integer> valToIndexMap = new TreeMap<>();
+    int[] digits = new int[String.valueOf(num).length()];
+    for (int i = digits.length - 1; i >= 0; i--) {
+      int digit = num % 10;
+      num /= 10;
+      digits[i] = digit;
+      valToIndexMap.putIfAbsent(digit, i);
+    }
+    for (int i = 0; i < digits.length; i++) {
+      for (int k = 9; k > digits[i]; k--) {
+        if (valToIndexMap.getOrDefault(k, -1) > i) {
+          int swapIndex = valToIndexMap.get(k);
+          return Integer.parseInt(
+              stringValue.substring(0, i) // Digits before swap index
+                  + k // Swapped value
+                  + stringValue.substring(i + 1, swapIndex) // Digits after original index(i) and before swappedIndex
+                  + digits[i] // Digit at original index(i)
+                  + ((swapIndex + 1) != stringValue.length() // Check if swapIndex is last digit of num
+                      ? stringValue.substring(swapIndex + 1) // If not then add digits that come after the swapIndex
+                      : "")); // Else add an empty string
+        }
+      }
+    }
+    return Integer.parseInt(stringValue);
+  }
+}

From 54bb131982e795802af4b364aa079d82166e5b61 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 17 Feb 2022 12:24:56 -0800
Subject: [PATCH 0790/2175] Update Maximum Swap.java

---
 Medium/Maximum Swap.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Medium/Maximum Swap.java b/Medium/Maximum Swap.java
index 530cbdaa..5d30c780 100644
--- a/Medium/Maximum Swap.java	
+++ b/Medium/Maximum Swap.java	
@@ -1,7 +1,7 @@
 class Solution {
   public int maximumSwap(int num) {
     String stringValue = Integer.toString(num);
-    Map<Integer, Integer> valToIndexMap = new TreeMap<>();
+    Map<Integer, Integer> valToIndexMap = new HashMap<>();
     int[] digits = new int[String.valueOf(num).length()];
     for (int i = digits.length - 1; i >= 0; i--) {
       int digit = num % 10;

From 655963b840f80d5625140697f5a9bef4f0a1f44c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 17 Feb 2022 13:23:01 -0800
Subject: [PATCH 0791/2175] Update Find Peak Element.java

---
 Medium/Find Peak Element.java | 29 +++++++++++------------------
 1 file changed, 11 insertions(+), 18 deletions(-)

diff --git a/Medium/Find Peak Element.java b/Medium/Find Peak Element.java
index b90994cc..5cc6feaa 100644
--- a/Medium/Find Peak Element.java	
+++ b/Medium/Find Peak Element.java	
@@ -1,25 +1,18 @@
 class Solution {
   public int findPeakElement(int[] nums) {
-    int[] index = {-1};
-    helper(nums, 0, nums.length - 1, index);
-    return index[0];
+    return helper(nums, 0, nums.length - 1);
   }
   
-  private void helper(int[] nums, int start, int end, int[] index) {
-    if (start <= end && index[0] == -1) {
-      int mid = (start + end) / 2;
-      boolean found = (
-          (mid + 1 < nums.length ? nums[mid] > nums[mid + 1] : true) &&
-          (mid - 1 >= 0 ? nums[mid] > nums[mid - 1] : true)
-        );
-      if (found) {
-        index[0] = mid;
-        return;
-      }
-      else {
-        helper(nums, start, mid - 1, index);
-        helper(nums, mid + 1, end, index);
-      }
+  private int helper(int[] nums, int startIdx, int endIdx) {
+    if (startIdx == endIdx) {
+      return startIdx;
+    }
+    int midIdx = (startIdx + endIdx) / 2;
+    int nextToMid = midIdx + 1;
+    if (nums[midIdx] > nums[nextToMid]) {
+      return helper(nums, startIdx, midIdx);
+    } else {
+      return helper(nums, nextToMid, endIdx);
     }
   }
 }

From e9e4c13f79c46dcd72ddfae4e37aee72a85864ae Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 18 Feb 2022 17:31:25 -0800
Subject: [PATCH 0792/2175] Update Minimize Deviation in Array.java

---
 Hard/Minimize Deviation in Array.java | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/Hard/Minimize Deviation in Array.java b/Hard/Minimize Deviation in Array.java
index cc449c6c..736ccbd0 100644
--- a/Hard/Minimize Deviation in Array.java	
+++ b/Hard/Minimize Deviation in Array.java	
@@ -1,21 +1,21 @@
 class Solution {
   public int minimumDeviation(int[] nums) {
-    int minimumValue = Integer.MAX_VALUE;
-    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b.compareTo(a));
+    int currMinimum = Integer.MAX_VALUE;
+    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((a, b) -> b - a);
     for (int num : nums) {
       if (num % 2 != 0) {
         num *= 2;
       }
-      minimumValue = Math.min(minimumValue, num);
-      pq.add(num);
+      currMinimum = Math.min(currMinimum, num);
+      priorityQueue.add(num);
     }
-    int result = Integer.MAX_VALUE;
-    while (pq.peek() % 2 == 0) {
-      int removed = pq.poll() / 2;
-      minimumValue = Math.min(minimumValue, removed);
-      pq.add(removed);
-      result = Math.min(result, pq.peek() - minimumValue);
+    int deviation = Integer.MAX_VALUE;
+    while (priorityQueue.peek() % 2 == 0) {
+      int removed = priorityQueue.poll() / 2;
+      currMinimum = Math.min(currMinimum, removed);
+      priorityQueue.add(removed);
+      deviation = Math.min(deviation, priorityQueue.peek() - currMinimum);
     }
-    return result;
+    return deviation;
   }
 }

From a28ade00166076dd934a89117a97eadb394b0b04 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 19 Feb 2022 17:46:37 -0800
Subject: [PATCH 0793/2175] Update Remove Covered Intervals.java

---
 Medium/Remove Covered Intervals.java | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/Medium/Remove Covered Intervals.java b/Medium/Remove Covered Intervals.java
index 3adf6ca3..03fdf662 100644
--- a/Medium/Remove Covered Intervals.java	
+++ b/Medium/Remove Covered Intervals.java	
@@ -7,18 +7,21 @@ public int removeCoveredIntervals(int[][] intervals) {
       }
       return o2[1] - o1[1];
     });
-    int count = 0;
-    int idx = 0;
+    int currIdx = 0;
     int n = intervals.length;
-    while (idx < n) {
-      int start = intervals[idx][0];
-      int end = intervals[idx][1];
-      idx++;
-      while (idx < n && intervals[idx][1] <= end) {
-        idx++;
+    int intervalCount = 0;
+    while (currIdx < n) {
+      int[] currInterval = intervals[currIdx];
+      int currIntervalStart = currInterval[0];
+      int currIntervalEnd = currInterval[1];
+      currIdx++;
+      while (currIdx < n &&
+          intervals[currIdx][0] >= currIntervalStart &&
+          intervals[currIdx][1] <= currIntervalEnd) {
+        currIdx++;
       }
-      count++;
+      intervalCount++;
     }
-    return count;
-  }
+    return intervalCount;
+  }   
 }

From b1cac2376a1e6720f63d022989c7c88eee83e572 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 19 Feb 2022 18:02:05 -0800
Subject: [PATCH 0794/2175] Create Count Equal and Divisible Pairs in an
 Array.java

---
 ...Equal and Divisible Pairs in an Array.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Count Equal and Divisible Pairs in an Array.java

diff --git a/Easy/Count Equal and Divisible Pairs in an Array.java b/Easy/Count Equal and Divisible Pairs in an Array.java
new file mode 100644
index 00000000..309c090a
--- /dev/null
+++ b/Easy/Count Equal and Divisible Pairs in an Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int countPairs(int[] nums, int k) {
+    Map<Integer, List<Integer>> map = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+      map.computeIfAbsent(nums[i], j -> new ArrayList<>()).add(i);
+    }
+    int numOfPairs = 0;
+    for (List<Integer> indices : map.values()) {
+      for (int i = 0; i < indices.size(); i++) {
+        for (int j = 0; j < i; j++) {
+          if (indices.get(i) * indices.get(j) % k == 0) {
+            numOfPairs++;
+          }
+        }
+      }
+    }
+    return numOfPairs;
+  }
+}

From 43ee6c89e4367d571da87d022cb455491d2a4f2f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Feb 2022 06:35:16 -0800
Subject: [PATCH 0795/2175] Create Count Integers With Even Digit Sum.java

---
 Easy/Count Integers With Even Digit Sum.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Count Integers With Even Digit Sum.java

diff --git a/Easy/Count Integers With Even Digit Sum.java b/Easy/Count Integers With Even Digit Sum.java
new file mode 100644
index 00000000..172a17d3
--- /dev/null
+++ b/Easy/Count Integers With Even Digit Sum.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int countEven(int num) {
+    return (int) IntStream.range(1, num + 1).boxed().filter(this::isSumOfDigitsEven).count();
+  }
+  
+  private boolean isSumOfDigitsEven(int num) {
+    int sum = 0;
+    while (num > 0) {
+      sum += num % 10;
+      num /= 10;
+    }
+    return sum % 2 == 0;
+  }
+}

From b199b039e76a4986815fa4263d4c1cbb56d24c3d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Feb 2022 16:12:27 -0800
Subject: [PATCH 0796/2175] Create Merge Nodes in Between Zeros.java

---
 Medium/Merge Nodes in Between Zeros.java | 32 ++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Merge Nodes in Between Zeros.java

diff --git a/Medium/Merge Nodes in Between Zeros.java b/Medium/Merge Nodes in Between Zeros.java
new file mode 100644
index 00000000..e4cb4403
--- /dev/null
+++ b/Medium/Merge Nodes in Between Zeros.java	
@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode mergeNodes(ListNode head) {
+    ListNode newHead = null;
+    ListNode prev = null;
+    ListNode curr = head.next;
+    while (curr != null) {
+      prev = curr;
+      if (newHead == null) {
+        newHead = prev;
+      }
+      int sum = 0;
+      while (curr != null && curr.val != 0) {
+        sum += curr.val;
+        curr = curr.next;
+      }
+      prev.val = sum;
+      curr = curr.next;
+      prev.next = curr;
+    }
+    return newHead;
+  }
+}

From 9a5783b4d45d73ae4c6d720a319b763078a7b171 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Feb 2022 11:53:56 -0800
Subject: [PATCH 0797/2175] Create Construct String With Repeat Limit.java

---
 .../Construct String With Repeat Limit.java   | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/Construct String With Repeat Limit.java

diff --git a/Medium/Construct String With Repeat Limit.java b/Medium/Construct String With Repeat Limit.java
new file mode 100644
index 00000000..4ac21148
--- /dev/null
+++ b/Medium/Construct String With Repeat Limit.java	
@@ -0,0 +1,37 @@
+class Solution {
+  public String repeatLimitedString(String s, int repeatLimit) {
+    PriorityQueue<Character> pq = new PriorityQueue<>((o1, o2) -> o2 - o1);
+    for (char c : s.toCharArray()) {
+      pq.add(c);
+    }
+    StringBuilder sb = new StringBuilder();
+    Stack<Character> stack = new Stack<>();
+    int currentCharacterCount = 0;
+    char previousCharacter = pq.peek();
+    while (!pq.isEmpty()) {
+      char currChar = pq.poll();
+      if (currChar == previousCharacter) {
+        if (currentCharacterCount < repeatLimit) {
+          sb.append(currChar);
+        } else {
+          stack.add(currChar);
+        }
+        currentCharacterCount++;
+      } else {
+        if (stack.isEmpty()) {
+          sb.append(currChar);
+          previousCharacter = currChar;
+          currentCharacterCount = 1;
+        } else {
+          sb.append(currChar);
+          currentCharacterCount = 0;
+          while (!stack.isEmpty() && currentCharacterCount < repeatLimit) {
+            sb.append(stack.pop());
+            currentCharacterCount++;
+          }
+        }
+      }
+    }
+    return sb.toString();
+  }
+}

From 70887cf8ae47b01622152bbd3c3e0364412157cf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Feb 2022 06:34:06 -0800
Subject: [PATCH 0798/2175] Update Excel Sheet Column Number.java

---
 Easy/Excel Sheet Column Number.java | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/Easy/Excel Sheet Column Number.java b/Easy/Excel Sheet Column Number.java
index dc59608e..44720a07 100644
--- a/Easy/Excel Sheet Column Number.java	
+++ b/Easy/Excel Sheet Column Number.java	
@@ -1,10 +1,12 @@
 class Solution {
-  public int titleToNumber(String s) {
-    int num = 0;
-    int pow = 0;
-    for (int i = s.length() - 1; i >= 0; i--) {
-      num += ((int) Math.pow(26, pow++)) * (s.charAt(i) - 'A' + 1);
+  public int titleToNumber(String columnTitle) {
+    int numericValue = 0;
+    int multiplier = 1;
+    for (int i = columnTitle.length() - 1; i >= 0; i--) {
+      int currCharNum = columnTitle.charAt(i) - 'A' + 1;
+      numericValue += multiplier * currCharNum;
+      multiplier *= 26;
     }
-    return num;
+    return numericValue; 
   }
 }

From bf8b54b566ef87fde6ba6f4a2979096847705279 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Feb 2022 11:46:10 -0800
Subject: [PATCH 0799/2175] Update Analyze User Website Visit Pattern.java

---
 .../Analyze User Website Visit Pattern.java   | 85 +++++++------------
 1 file changed, 32 insertions(+), 53 deletions(-)

diff --git a/Medium/Analyze User Website Visit Pattern.java b/Medium/Analyze User Website Visit Pattern.java
index def6a086..1fbb2fc3 100644
--- a/Medium/Analyze User Website Visit Pattern.java	
+++ b/Medium/Analyze User Website Visit Pattern.java	
@@ -1,62 +1,41 @@
 class Solution {
   public List<String> mostVisitedPattern(String[] username, int[] timestamp, String[] website) {
-    Map<String, List<WebEntry>> map = new HashMap<>();
-    for (int i = 0; i < timestamp.length; i++) {
-      map.computeIfAbsent(username[i], k -> new ArrayList<>()).add(
-        new WebEntry(website[i], timestamp[i], username[i])
-      );
+    Map<String, List<Integer>> userToVisitMapping = new HashMap<>();
+    for (int i = 0; i < username.length; i++) {
+      userToVisitMapping.computeIfAbsent(username[i], k -> new ArrayList<>()).add(i);
     }
-    Map<String, Set<String>> visitMap = new HashMap<>();
-    Set<String> threeSequenceSet = new HashSet<>(); 
-    for (String key : map.keySet()) {
-      List<WebEntry> webentries = map.get(key);
-      Collections.sort(webentries, new Comparator<WebEntry>(){
-        public int compare(WebEntry w1, WebEntry w2) {
-          return w1.timestamp - w2.timestamp;
-        }
-      });
-      for (int i = 0; i < webentries.size(); i++) {
-        for (int j = i + 1; j < webentries.size(); j++) {
-          for (int k = j + 1; k < webentries.size(); k++) {
-            String websiteKey = (
-              webentries.get(i).website + " " + 
-              webentries.get(j).website + " " + 
-              webentries.get(k).website
-            );
-            visitMap.computeIfAbsent(websiteKey, m -> new HashSet<>()).add(key);
-            threeSequenceSet.add(websiteKey);
+    Map<String, Set<String>> patternToUserMapping = new HashMap<>();
+    int maxCount = 0;
+    String resultingPattern = null;
+    for (String key : userToVisitMapping.keySet()) {
+      List<String> visitedWebsiteInOrder =
+          userToVisitMapping.get(key).stream()
+              .sorted(Comparator.comparingInt(a -> timestamp[a]))
+              .map(i -> website[i])
+              .collect(Collectors.toList());
+      for (int i = 0; i < visitedWebsiteInOrder.size() - 2; i++) {
+        for (int j = i + 1; j < visitedWebsiteInOrder.size() - 1; j++) {
+          for (int k = j + 1; k < visitedWebsiteInOrder.size(); k++) {
+            String pattern =
+                visitedWebsiteInOrder.get(i)
+                    + " "
+                    + visitedWebsiteInOrder.get(j)
+                    + " "
+                    + visitedWebsiteInOrder.get(k);
+            patternToUserMapping.computeIfAbsent(pattern, l -> new HashSet<>()).add(key);
+            if (maxCount <= patternToUserMapping.get(pattern).size()) {
+              if (maxCount < patternToUserMapping.get(pattern).size()) {
+                resultingPattern = pattern;
+                maxCount = patternToUserMapping.get(pattern).size();
+              } else if (pattern.compareTo(resultingPattern) < 0) {
+                resultingPattern = pattern;
+              }
+            }
+            maxCount = Math.max(maxCount, patternToUserMapping.get(pattern).size());
           }
         }
       }
     }
-    List<String> threeSequenceList = new ArrayList<>(threeSequenceSet);
-    Collections.sort(threeSequenceList, new Comparator<String>(){
-      public int compare(String s1, String s2) {
-        int c = visitMap.get(s2).size() - visitMap.get(s1).size();
-        if (c != 0) {
-          return c;
-        }
-        return s1.compareTo(s2);
-      }
-    });
-    String[] ansArr = threeSequenceList.get(0).split("\\s+");
-    List<String> ans = new ArrayList<>();
-    for (int i = 0; i < ansArr.length; i++) {
-      ans.add(ansArr[i]);
-    }
-    return ans;
-  }
-}
-
-
-class WebEntry {
-  String website;
-  int timestamp;
-  String username;
-  
-  public WebEntry(String website, int timestamp, String username) {
-    this.website = website;
-    this.timestamp = timestamp;
-    this.username = username;
+    return Arrays.stream(resultingPattern.split("\\s+")).collect(Collectors.toList());
   }
 }

From bd1c4aff54cb1f49ac6c20dfe0c7d5c1a19dee10 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Feb 2022 14:22:04 -0800
Subject: [PATCH 0800/2175] Update Kill Process.java

---
 Medium/Kill Process.java | 28 ++++++++++++----------------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/Medium/Kill Process.java b/Medium/Kill Process.java
index 623bf04f..e0f5cbf7 100644
--- a/Medium/Kill Process.java	
+++ b/Medium/Kill Process.java	
@@ -1,25 +1,21 @@
 class Solution {
   public List<Integer> killProcess(List<Integer> pid, List<Integer> ppid, int kill) {
-    Map<Integer, List<Integer>> map = new HashMap<>();
+    Map<Integer, Set<Integer>> map = new HashMap<>();
     for (int i = 0; i < pid.size(); i++) {
-      if (ppid.get(i) != 0) {
-        map.computeIfAbsent(ppid.get(i), k -> new ArrayList<>()).add(pid.get(i));
-      }
+      map.computeIfAbsent(ppid.get(i), k -> new HashSet<>()).add(pid.get(i));
     }
-    Set<Integer> set = new HashSet<>();
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(kill);
-    set.add(kill);
-    while (!queue.isEmpty()) {
-      int removed = queue.remove();
-      set.add(removed);
-      for (Integer child : map.getOrDefault(removed, new ArrayList<>())) {
-        if (!set.contains(child)) {
-          queue.add(child);
-          set.add(child);
+    Stack<Integer> stack = new Stack<>();
+    stack.push(kill);
+    Set<Integer> tasksKilled = new HashSet<>();
+    while (!stack.isEmpty()) {
+      int removedTask = stack.pop();
+      tasksKilled.add(removedTask);
+      for (Integer childTask : map.getOrDefault(removedTask, new HashSet<>())) {
+        if (!tasksKilled.contains(childTask)) {
+          stack.push(childTask);
         }
       }
     }
-    return new ArrayList<>(set);
+    return new ArrayList<>(tasksKilled);
   }
 }

From 759dc8e25b6ab4216febb8d5d3e47b3308eca6f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Feb 2022 15:11:33 -0800
Subject: [PATCH 0801/2175] Create Print FooBar Alternately.java

---
 Concurrency/Print FooBar Alternately.java | 32 +++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Concurrency/Print FooBar Alternately.java

diff --git a/Concurrency/Print FooBar Alternately.java b/Concurrency/Print FooBar Alternately.java
new file mode 100644
index 00000000..f19a774f
--- /dev/null
+++ b/Concurrency/Print FooBar Alternately.java	
@@ -0,0 +1,32 @@
+class FooBar {
+  private int n;
+
+  private Semaphore fooSemaphore = new Semaphore(1);
+  private Semaphore barSemaphore = new Semaphore(0);
+
+  public FooBar(int n) {
+    this.n = n;
+  }
+
+  public void foo(Runnable printFoo) throws InterruptedException {
+
+    for (int i = 0; i < n; i++) {
+
+      // printFoo.run() outputs "foo". Do not change or remove this line.
+      fooSemaphore.acquire();
+      printFoo.run();
+      barSemaphore.release();
+    }
+  }
+
+  public void bar(Runnable printBar) throws InterruptedException {
+
+    for (int i = 0; i < n; i++) {
+
+      // printBar.run() outputs "bar". Do not change or remove this line.
+      barSemaphore.acquire();
+      printBar.run();
+      fooSemaphore.release();
+    }
+  }
+}

From aea67f15b6b98062d1d9d17fb2085c6bb7d1b545 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 23 Feb 2022 15:58:06 -0800
Subject: [PATCH 0802/2175] Create Print Zero Even Odd.java

---
 Concurrency/Print Zero Even Odd.java | 42 ++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Concurrency/Print Zero Even Odd.java

diff --git a/Concurrency/Print Zero Even Odd.java b/Concurrency/Print Zero Even Odd.java
new file mode 100644
index 00000000..35b3a599
--- /dev/null
+++ b/Concurrency/Print Zero Even Odd.java	
@@ -0,0 +1,42 @@
+class ZeroEvenOdd {
+  private int n;
+  private int flag = 0;
+
+  public ZeroEvenOdd(int n) {
+    this.n = n;
+  }
+
+  // printNumber.accept(x) outputs "x", where x is an integer.
+  public synchronized void zero(IntConsumer printNumber) throws InterruptedException {
+    for (int i = 0; i < n; i++) {
+      while (flag != 0) {
+        this.wait();
+      }
+      printNumber.accept(0);
+      flag = i % 2 == 0 ? 1 : 2;
+      this.notifyAll();
+    }
+  }
+
+  public synchronized void even(IntConsumer printNumber) throws InterruptedException {
+    for (int i = 2; i <= n; i += 2) {
+      while (flag != 2) {
+        this.wait();
+      }
+      printNumber.accept(i);
+      flag = 0;
+      this.notifyAll();
+    }
+  }
+
+  public synchronized void odd(IntConsumer printNumber) throws InterruptedException {
+    for (int i = 1; i <= n; i += 2) {
+      while (flag != 1) {
+        this.wait();
+      }
+      printNumber.accept(i);
+      flag = 0;
+      this.notifyAll();
+    }
+  }
+}

From af2f2728d52abc159681ee7f88d4b6211d70984b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 23 Feb 2022 18:35:52 -0800
Subject: [PATCH 0803/2175] Update Sort List.java

---
 Medium/Sort List.java | 59 +++++++++++++++++++++++--------------------
 1 file changed, 31 insertions(+), 28 deletions(-)

diff --git a/Medium/Sort List.java b/Medium/Sort List.java
index 2e0492e6..013db8f6 100644
--- a/Medium/Sort List.java	
+++ b/Medium/Sort List.java	
@@ -13,38 +13,41 @@ public ListNode sortList(ListNode head) {
     if (head == null || head.next == null) {
       return head;
     }
-    ListNode mid = getMid(head);
-    ListNode left = sortList(head);
-    ListNode right = sortList(mid);
-    return merge(left, right);
-  }
-  
-  private ListNode getMid(ListNode head) {
-    ListNode prev = null;
-    while (head != null && head.next != null) {
-      prev = prev == null ? head : prev.next;
-      head = head.next.next;
+    ListNode firstHalfTail = head;
+    ListNode secondHalfHead = head;
+    ListNode secondHalfTail = head;
+    while (secondHalfTail != null && secondHalfTail.next != null) {
+      firstHalfTail = secondHalfHead;
+      secondHalfHead = secondHalfHead.next;
+      secondHalfTail = secondHalfTail.next.next;
     }
-    ListNode mid = prev.next;
-    prev.next = null;
-    return mid;
+    firstHalfTail.next = null;
+    ListNode leftHalf = sortList(head);
+    ListNode rightHalf = sortList(secondHalfHead);
+    return merge(leftHalf, rightHalf);
   }
   
-  private ListNode merge(ListNode l1, ListNode l2) {
-    ListNode dummyHead = new ListNode();
-    ListNode tail = dummyHead;
-    while (l1 != null && l2 != null) {
-      if (l1.val < l2.val) {
-        tail.next = l1;
-        l1 = l1.next;
-      }
-      else {
-        tail.next = l2;
-        l2 = l2.next;
+  private ListNode merge(ListNode leftHalf, ListNode rightHalf) {
+    ListNode dummyNode = new ListNode(-1);
+    ListNode currNode = dummyNode;
+    while (leftHalf != null || rightHalf != null) {
+      if (leftHalf != null && rightHalf != null) {
+        if (leftHalf.val < rightHalf.val) {
+          currNode.next = new ListNode(leftHalf.val);
+          leftHalf = leftHalf.next;
+        } else {
+          currNode.next = new ListNode(rightHalf.val);
+          rightHalf = rightHalf.next;
+        }
+      } else if (leftHalf != null && rightHalf == null) {
+        currNode.next = new ListNode(leftHalf.val);
+        leftHalf = leftHalf.next;
+      } else {
+        currNode.next = new ListNode(rightHalf.val);
+        rightHalf = rightHalf.next;
       }
-      tail = tail.next;
+      currNode = currNode.next;
     }
-    tail.next = l1 != null ? l1 : l2;
-    return dummyHead.next;
+    return dummyNode.next;
   }
 }

From d96d64013ab792911a9593792505dc491c167a36 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 24 Feb 2022 06:58:41 -0800
Subject: [PATCH 0804/2175] Update Binary Tree Longest Consecutive
 Sequence.java

---
 ...ary Tree Longest Consecutive Sequence.java | 61 +++++++++++--------
 1 file changed, 34 insertions(+), 27 deletions(-)

diff --git a/Medium/Binary Tree Longest Consecutive Sequence.java b/Medium/Binary Tree Longest Consecutive Sequence.java
index b5f278aa..92a3e1b4 100644
--- a/Medium/Binary Tree Longest Consecutive Sequence.java	
+++ b/Medium/Binary Tree Longest Consecutive Sequence.java	
@@ -4,37 +4,44 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int longestConsecutive(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
-        
-        int[] ans = {1};
-        helper(root, ans, null, 1);
-        
-        return ans[0];
+  public int longestConsecutive(TreeNode root) {
+    int maxLength = 0;
+    Queue<NodePair> queue = new LinkedList<>();
+    queue.add(new NodePair(root, 1));
+    while (!queue.isEmpty()) {
+      NodePair removed = queue.remove();
+      maxLength = Math.max(maxLength, removed.currLength);
+      if (removed.node.left != null) {
+        int sequenceLength = (removed.node.left.val == removed.node.val + 1 
+                              ? removed.currLength + 1 : 1);
+        queue.add(new NodePair(removed.node.left, sequenceLength));
+      }
+      if (removed.node.right != null) {
+        int sequenceLength = (removed.node.right.val == removed.node.val + 1 
+                              ? removed.currLength + 1 : 1);
+        queue.add(new NodePair(removed.node.right, sequenceLength));
+      }
     }
+    return maxLength;
+  }
+  
+  private class NodePair {
+    TreeNode node;
+    int currLength;
     
-    private void helper(TreeNode root, int[] ans, TreeNode parent, int count) {
-        if (root == null) {
-            return;
-        }
-        
-        if (parent != null) {
-            if (root.val == parent.val + 1) {
-                count++;
-                ans[0] = Math.max(ans[0], count);
-            }
-            else {
-                count = 1;
-            }
-        }
-        
-        helper(root.left, ans, root, count);
-        helper(root.right, ans, root, count);
+    public NodePair(TreeNode node, int currLength) {
+      this.node = node;
+      this.currLength = currLength;
     }
+  }
 }

From f8a0484622792e841d01c2b29be47e9811db3d2a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 24 Feb 2022 07:17:13 -0800
Subject: [PATCH 0805/2175] Create Tree Diameter.java

---
 Medium/Tree Diameter.java | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 Medium/Tree Diameter.java

diff --git a/Medium/Tree Diameter.java b/Medium/Tree Diameter.java
new file mode 100644
index 00000000..28dca810
--- /dev/null
+++ b/Medium/Tree Diameter.java	
@@ -0,0 +1,36 @@
+class Solution {
+  public int treeDiameter(int[][] edges) {
+    Map<Integer, List<Integer>> graph = new HashMap<>();
+    for (int[] edge : edges) {
+      graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    }
+    int farthestNode = bfsHelper(graph, 0)[0];
+    return bfsHelper(graph, farthestNode)[1];
+  }
+
+  private int[] bfsHelper(Map<Integer, List<Integer>> graph, int node) {
+    int farthestNode = 0;
+    int steps = 0;
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(node);
+    Set<Integer> visited = new HashSet<>();
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size--  > 0) {
+        int removedNode = queue.remove();
+        visited.add(removedNode);
+        farthestNode = removedNode;
+        for (Integer peer : graph.getOrDefault(removedNode, new ArrayList<>())) {
+          if (!visited.contains(peer)) {
+            queue.add(peer);
+          }
+        }
+      }
+      if (!queue.isEmpty()) {
+        steps++;
+      }
+    }
+    return new int[]{farthestNode, steps};
+  }
+}

From d88f76c4a11de05bd1621dbbe4c935ca9a811a2a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 25 Feb 2022 08:00:30 -0800
Subject: [PATCH 0806/2175] Update Compare Version Numbers.java

---
 Medium/Compare Version Numbers.java | 52 +++++++++++++++--------------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/Medium/Compare Version Numbers.java b/Medium/Compare Version Numbers.java
index f41cecb0..94e1e7ed 100644
--- a/Medium/Compare Version Numbers.java	
+++ b/Medium/Compare Version Numbers.java	
@@ -1,31 +1,33 @@
 class Solution {
   public int compareVersion(String version1, String version2) {
-    String[] versionSplit1 = version1.split("\\.");
-    String[] versionSplit2 = version2.split("\\.");
-    int idx1 = 0;
-    int idx2 = 0;
-    while (idx1 < versionSplit1.length || idx2 < versionSplit2.length) {
-      if (idx1 < versionSplit1.length && idx2 < versionSplit2.length) {
-        int ver1 = Integer.parseInt(versionSplit1[idx1++]);
-        int ver2 = Integer.parseInt(versionSplit2[idx2++]);
-        int c = ver1 - ver2;
-        if (c != 0) {
-          return c > 0 ? 1 : -1;
-        }
-      }
-      else if (idx1 < versionSplit1.length || idx2 == versionSplit2.length) {
-        int ver1 = Integer.parseInt(versionSplit1[idx1++]);
-        if (ver1 != 0) {
-          return 1;
-        }
-      }
-      else {
-        int ver2 = Integer.parseInt(versionSplit2[idx2++]);
-        if (ver2 != 0) {
-          return -1;
-        }
+    String[] versionOneSplit = version1.split("\\.");
+    String[] versionTwoSplit = version2.split("\\.");
+    int idxOne = 0;
+    int idxTwo = 0;
+    while (idxOne < versionOneSplit.length && idxTwo < versionTwoSplit.length) {
+      int diff = Integer.parseInt(versionOneSplit[idxOne]) - Integer.parseInt(versionTwoSplit[idxTwo]);
+      if (diff < 0) {
+        return -1;
+      } else if (diff > 0) {
+        return 1;
       }
+      idxOne++;
+      idxTwo++;
+    }
+    if (containsNonZeroRevision(versionOneSplit, idxOne)) {
+      return 1;
+    } else if (containsNonZeroRevision(versionTwoSplit, idxTwo)) {
+      return -1;
     }
     return 0;
-  } 
+  }
+  
+  private boolean containsNonZeroRevision(String[] versions, int idx) {
+    for (int i = idx; i < versions.length; i++) {
+      if (Integer.parseInt(versions[i]) > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
 }

From a63aac50ad8c557c505b1aa9c2e15c8efee77a62 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 25 Feb 2022 14:01:58 -0800
Subject: [PATCH 0807/2175] Update Flood Fill.java

---
 Easy/Flood Fill.java | 41 ++++++++++++++++++++++++++---------------
 1 file changed, 26 insertions(+), 15 deletions(-)

diff --git a/Easy/Flood Fill.java b/Easy/Flood Fill.java
index 38cb718e..e3806b21 100644
--- a/Easy/Flood Fill.java	
+++ b/Easy/Flood Fill.java	
@@ -1,20 +1,31 @@
 class Solution {
-    public int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
-        dfs(image, sr, sc, newColor, image[sr][sc]);
-        return image;
+  private static final int[][] DIRS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+  
+  public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
+    int numOfRows = image.length;
+    int numOfCols = image[0].length;
+    int originalColor = image[sr][sc];
+    if (newColor == originalColor) {
+      return image;
     }
-    
-    private void dfs(int[][] image, int x, int y, int newColor, int oldColor) {
-        if(x < 0 || x >= image.length || y < 0 || y >= image[0].length || image[x][y] == newColor) {
-            return;
-        }
-        
-        if (image[x][y] == oldColor) {
-            image[x][y] = newColor;
-            for (int[] dir : dirs) {
-                dfs(image, x + dir[0], y + dir[1], newColor, oldColor);
-            }
+    Queue<int[]> queue = new LinkedList<>();
+    queue.add(new int[]{sr, sc});
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int[] coordinate = queue.remove();
+        int xPoint = coordinate[0];
+        int yPoint = coordinate[1];
+        image[xPoint][yPoint] = newColor;
+        for (int[] dir : DIRS) {
+          int newXPoint = xPoint + dir[0];
+          int newYPoint = yPoint + dir[1];
+          if (newXPoint >= 0 && newYPoint >= 0 && newXPoint < numOfRows && newYPoint < numOfCols && image[newXPoint][newYPoint] == originalColor) {
+            queue.add(new int[]{newXPoint, newYPoint});
+          }
         }
+      }
     }
+    return image;
+  }
 }

From e024e06c84abfa054e9f942f5572d0da5d096127 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 25 Feb 2022 14:42:26 -0800
Subject: [PATCH 0808/2175] Update Number of Islands.java

---
 Medium/Number of Islands.java | 47 +++++++++++++++++++----------------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/Medium/Number of Islands.java b/Medium/Number of Islands.java
index 1d6c2a87..cebe59c1 100644
--- a/Medium/Number of Islands.java	
+++ b/Medium/Number of Islands.java	
@@ -1,35 +1,38 @@
 class Solution {
+  
+  private static final int[][] DIRS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+  
   public int numIslands(char[][] grid) {
-    if (grid.length == 0 || grid[0].length == 0) {
-      return 0;
-    }
-    int rows = grid.length;
-    int cols = grid[0].length;
-    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-    boolean[][] visited = new boolean[rows][cols];
-    int count = 0;
-    for (int i = 0; i < rows; i++) {
-      for (int j = 0; j < cols; j++) {
-        if (grid[i][j] == '1' && !visited[i][j]) {
+    int countOfIslands = 0;
+    int numOfRows = grid.length;
+    int numOfCols = grid[0].length;
+    boolean[][] visited = new boolean[numOfRows][numOfCols];
+    for (int i = 0; i < numOfRows; i++) {
+      for (int j = 0; j < numOfCols; j++) {
+        if (!visited[i][j] && grid[i][j] == '1') {
           Queue<int[]> queue = new LinkedList<>();
           queue.add(new int[]{i, j});
-          visited[i][j] = true;
           while (!queue.isEmpty()) {
-            int[] removed = queue.remove();
-            for (int[] dir : dirs) {
-              int newX = removed[0] + dir[0];
-              int newY = removed[1] + dir[1];
-              if (newX < 0 || newX >= rows || newY < 0 || newY >= cols || visited[newX][newY] || grid[newX][newY] == '0') {
-                continue;
+            int size = queue.size();
+            while (size-- > 0) {
+              int[] removed = queue.remove();
+              int currX = removed[0];
+              int currY = removed[1];
+              visited[currX][currY] = true;
+              for (int[] dir : DIRS) {
+                int newX = currX + dir[0];
+                int newY = currY + dir[1];
+                if (newX >= 0 && newY >= 0 && newX < numOfRows && newY < numOfCols && !visited[newX][newY] && grid[newX][newY] == '1') {
+                  queue.add(new int[]{newX, newY});
+                  visited[newX][newY] = true;
+                }
               }
-              visited[newX][newY] = true;
-              queue.add(new int[]{newX, newY});
             }
           }
-          count++;
+          countOfIslands++;
         }
       }
     }
-    return count;
+    return countOfIslands;
   }
 }

From 1d42b90e566e309037aa3653f505c8611d5cb346 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Feb 2022 13:51:24 -0800
Subject: [PATCH 0809/2175] Create Number of Closed Islands.java

---
 Medium/Number of Closed Islands.java | 32 ++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Number of Closed Islands.java

diff --git a/Medium/Number of Closed Islands.java b/Medium/Number of Closed Islands.java
new file mode 100644
index 00000000..e55843c5
--- /dev/null
+++ b/Medium/Number of Closed Islands.java	
@@ -0,0 +1,32 @@
+class Solution {
+  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
+  public int closedIsland(int[][] grid) {
+    int numberOfClosedIslands = 0;
+    for(int i = 0; i < grid.length; i++){
+      for(int j = 0; j < grid[0].length; j++){
+        if(grid[i][j] == 0){
+          if(surroundsSuccessfully(grid, i, j)) {
+            numberOfClosedIslands++;
+          }
+        }
+      }
+    }
+    return numberOfClosedIslands;
+  }
+
+  private boolean surroundsSuccessfully(int[][] grid, int x, int y) {
+    if(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length) {
+      return false;
+    }
+    if(grid[x][y] == 1) {
+      return true;
+    }
+    grid[x][y] = 1;
+    boolean result = true;
+    for(int[] dir : DIRS){
+      result = result & surroundsSuccessfully(grid, x + dir[0], y + dir[1]);
+    }
+    return result;
+  }
+}

From 805b8c8003b283b6f3d28e87f596c8d4e4721b6d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Feb 2022 17:17:57 -0800
Subject: [PATCH 0810/2175] Update Maximum Width of Binary Tree.java

---
 Medium/Maximum Width of Binary Tree.java | 49 +++++++++++++++++-------
 1 file changed, 35 insertions(+), 14 deletions(-)

diff --git a/Medium/Maximum Width of Binary Tree.java b/Medium/Maximum Width of Binary Tree.java
index a236cec3..3610e37d 100644
--- a/Medium/Maximum Width of Binary Tree.java	
+++ b/Medium/Maximum Width of Binary Tree.java	
@@ -4,24 +4,45 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public int widthOfBinaryTree(TreeNode root) {
-    int[] ans = {0};
-    Map<Integer, Integer> map = new HashMap<>();
-    dfs(root, 0, 0, ans, map);
-    return ans[0];
-  }
-  
-  private void dfs(TreeNode root, int depth, int pos, int[] ans, Map<Integer, Integer> map) {
-    if (root == null) {
-      return;
+    int maxWidth = 0;
+    Queue<TreeNode> queue = new LinkedList<>();
+    Map<TreeNode, Integer> map = new HashMap<>();
+    map.put(root, 1);
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      int start = 0;
+      int end = 0;
+      for (int i = 0; i < size; i++) {
+        TreeNode node = queue.poll();
+        if (i == 0) {
+          start = map.get(node);
+        }
+        if (i == size - 1) {
+          end = map.get(node);
+        }
+        if (node.left != null) {
+          map.put(node.left, map.get(node) * 2);
+          queue.add(node.left);
+        }
+        if (node.right != null) {
+          map.put(node.right, map.get(node) * 2 + 1);
+          queue.add(node.right);
+        }
+      }
+      maxWidth = Math.max(maxWidth, end - start + 1);
     }
-    map.putIfAbsent(depth, pos);
-    ans[0] = Math.max(ans[0], pos - map.get(depth) + 1);
-    dfs(root.left, depth + 1, 2 * pos, ans, map);
-    dfs(root.right, depth + 1, 2 * pos + 1, ans, map);
+    return maxWidth;
   }
 }

From 6586b0cc7372b046a3bbca4ae6bece859b76947f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Feb 2022 07:31:42 -0800
Subject: [PATCH 0811/2175] Create Counting Words With a Given Prefix.java

---
 Easy/Counting Words With a Given Prefix.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Counting Words With a Given Prefix.java

diff --git a/Easy/Counting Words With a Given Prefix.java b/Easy/Counting Words With a Given Prefix.java
new file mode 100644
index 00000000..b3ed8f47
--- /dev/null
+++ b/Easy/Counting Words With a Given Prefix.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public int prefixCount(String[] words, String pref) {
+    return (int) Arrays.stream(words).filter(w -> w.startsWith(pref)).count();
+  }
+}

From 3393e5c9fd8979ef48d66f3401f867236424a589 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Feb 2022 07:35:03 -0800
Subject: [PATCH 0812/2175] Create Minimum Number of Steps to Make Two Strings
 Anagram II.java

---
 ... of Steps to Make Two Strings Anagram II.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Minimum Number of Steps to Make Two Strings Anagram II.java

diff --git a/Medium/Minimum Number of Steps to Make Two Strings Anagram II.java b/Medium/Minimum Number of Steps to Make Two Strings Anagram II.java
new file mode 100644
index 00000000..0c72d548
--- /dev/null
+++ b/Medium/Minimum Number of Steps to Make Two Strings Anagram II.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int minSteps(String s, String t) {
+    int[] frequency = new int[26];
+    for (char c : s.toCharArray()) {
+      frequency[c - 'a']++;
+    }
+    for (char c : t.toCharArray()) {
+      frequency[c - 'a']--;
+    }
+    int totalSteps = 0;
+    for (int i = 0; i < 26; i++) {
+      totalSteps += Math.abs(frequency[i]);
+    }
+    return totalSteps;
+  }
+}

From 8dbd2a7cdc78cd50e6b59ab6a194a379ac8632a0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Feb 2022 07:51:52 -0800
Subject: [PATCH 0813/2175] Create Minimum Time to Complete Trips.java

---
 Medium/Minimum Time to Complete Trips.java | 27 ++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Minimum Time to Complete Trips.java

diff --git a/Medium/Minimum Time to Complete Trips.java b/Medium/Minimum Time to Complete Trips.java
new file mode 100644
index 00000000..901a3e57
--- /dev/null
+++ b/Medium/Minimum Time to Complete Trips.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public long minimumTime(int[] time, int totalTrips) {
+    long minTime = 1;
+    long fastestBus = time[0];
+    for (int t : time) {
+      fastestBus = Math.min(fastestBus, t);
+    }
+    long maxTime = fastestBus * totalTrips;
+    while (minTime < maxTime) {
+      long midTime = minTime + (maxTime - minTime) / 2;
+      if (getNumberOfTripsWithTime(time, midTime) >= totalTrips) {
+        maxTime = midTime;
+      } else {
+        minTime = midTime + 1;
+      }
+    }
+    return minTime;
+  }
+  
+  private long getNumberOfTripsWithTime(int[] time, long currentTime) {
+    long totalTrips = 0;
+    for (int t : time) {
+      totalTrips += currentTime / t;
+    }
+    return totalTrips;
+  }
+}

From d18e14c97800559c55b0e6c2e8a49e05f869d84c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Feb 2022 06:58:17 -0800
Subject: [PATCH 0814/2175] Create Number of Enclaves.java

---
 Medium/Number of Enclaves.java | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Medium/Number of Enclaves.java

diff --git a/Medium/Number of Enclaves.java b/Medium/Number of Enclaves.java
new file mode 100644
index 00000000..105942a1
--- /dev/null
+++ b/Medium/Number of Enclaves.java	
@@ -0,0 +1,30 @@
+class Solution {
+  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+  public int numEnclaves(int[][] grid) {
+    Queue<int[]> queue = new LinkedList<>();
+    int result = 0;
+    for (int i = 0; i < grid.length; i++) {
+      for (int j = 0; j < grid[0].length; j++) {
+        result += grid[i][j];
+        if (i * j == 0 || i == grid.length - 1 || j == grid[i].length - 1) {
+          queue.add(new int[]{i, j});
+        }
+      }
+    }
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int x = removed[0];
+      int y = removed[1];
+      if (x < 0 || y < 0 || x == grid.length || y == grid[0].length || grid[x][y] != 1) {
+        continue;
+      }
+      grid[x][y] = 0;
+      result--;
+      for (int[] dir : DIRS) {
+        queue.add(new int[]{x + dir[0], y + dir[1]});
+      }
+    }
+    return result;
+  }
+}

From 14ad3b99f4240c9569331f6da983816c0d4ab4b0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Feb 2022 11:20:50 -0800
Subject: [PATCH 0815/2175] Update Merge Sorted Array.java

---
 Easy/Merge Sorted Array.java | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/Easy/Merge Sorted Array.java b/Easy/Merge Sorted Array.java
index a1baa0d2..e99999f0 100644
--- a/Easy/Merge Sorted Array.java	
+++ b/Easy/Merge Sorted Array.java	
@@ -1,13 +1,19 @@
 class Solution {
   public void merge(int[] nums1, int m, int[] nums2, int n) {
-    int idx = m + n - 1;
-    while (m > 0 || n > 0) {
-      if (m > 0 && n > 0) {
-        nums1[idx--] = nums1[m - 1] > nums2[n - 1] ? nums1[m-- - 1] : nums2[n-- - 1];
-      } else if (m > 0 && n == 0) {
-        nums1[idx--] = nums1[m-- - 1];
+    int endIdxOne = m - 1;
+    int endIdxTwo = n - 1;
+    int currIdx = m + n - 1;
+    while (endIdxOne >= 0 || endIdxTwo >= 0) {
+      if (endIdxOne >= 0 && endIdxTwo >= 0) {
+        if (nums1[endIdxOne] > nums2[endIdxTwo]) {
+          nums1[currIdx--] = nums1[endIdxOne--];
+        } else {
+          nums1[currIdx--] = nums2[endIdxTwo--];          
+        }
+      } else if (endIdxOne >= 0 && endIdxTwo < 0) {
+        nums1[currIdx--] = nums1[endIdxOne--];
       } else {
-        nums1[idx--] = nums2[n-- - 1];
+        nums1[currIdx--] = nums2[endIdxTwo--];
       }
     }
   }

From 49f3bb0a0b33e7866c83c0c3a988444886889637 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 07:18:56 -0800
Subject: [PATCH 0816/2175] Update Shortest Word Distance II.java

---
 Medium/Shortest Word Distance II.java | 41 ++++++++++++++-------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/Medium/Shortest Word Distance II.java b/Medium/Shortest Word Distance II.java
index 7dbb3799..3a33f75d 100644
--- a/Medium/Shortest Word Distance II.java	
+++ b/Medium/Shortest Word Distance II.java	
@@ -1,33 +1,36 @@
 class WordDistance {
-  Map<String, List<Integer>> map;
-  public WordDistance(String[] words) {
-    map = new HashMap<>();
-    for (int i = 0; i < words.length; i++) {
-      map.computeIfAbsent(words[i], k -> new ArrayList<>()).add(i);
+  
+  private Map<String, List<Integer>> locations;
+
+  public WordDistance(String[] wordsDict) {
+    this.locations = new HashMap<>();
+    for (int i = 0; i < wordsDict.length; i++) {
+      this.locations.computeIfAbsent(wordsDict[i], k -> new ArrayList<>()).add(i);
     }
   }
 
   public int shortest(String word1, String word2) {
-    List<Integer> idxList1 = map.get(word1);
-    List<Integer> idxList2 = map.get(word2);
-    int idx1 = 0;
-    int idx2 = 0;
-    int minDiff = Math.abs(idxList1.get(idx1) - idxList2.get(idx2));
-    while (idx1 < idxList1.size() && idx2 < idxList2.size()) {
-      minDiff = Math.min(minDiff, Math.abs(idxList1.get(idx1) - idxList2.get(idx2)));
-      if (idxList1.get(idx1) < idxList2.get(idx2)) {
-        idx1++;
-      }
-      else {
-        idx2++;
+    List<Integer> indicesOne = this.locations.get(word1);
+    List<Integer> indicesTwo = this.locations.get(word2);
+    int idxOne = 0;
+    int idxTwo = 0;
+    int minimumIndexDifference = Integer.MAX_VALUE;
+    while (idxOne < indicesOne.size() && idxTwo < indicesTwo.size()) {
+      minimumIndexDifference = Math.min(
+        minimumIndexDifference, 
+        Math.abs(indicesOne.get(idxOne) - indicesTwo.get(idxTwo)));
+      if (indicesOne.get(idxOne) < indicesTwo.get(idxTwo)) {
+        idxOne++;
+      } else {
+        idxTwo++;
       }
     }
-    return minDiff;
+    return minimumIndexDifference;
   }
 }
 
 /**
  * Your WordDistance object will be instantiated and called as such:
- * WordDistance obj = new WordDistance(words);
+ * WordDistance obj = new WordDistance(wordsDict);
  * int param_1 = obj.shortest(word1,word2);
  */

From c286b3b8b50977438925981a69df41c2734635a7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 10:31:03 -0800
Subject: [PATCH 0817/2175] Update Counting Bits.java

---
 Medium/Counting Bits.java | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/Medium/Counting Bits.java b/Medium/Counting Bits.java
index ee39c468..4d948810 100644
--- a/Medium/Counting Bits.java	
+++ b/Medium/Counting Bits.java	
@@ -1,13 +1,9 @@
 class Solution {
-    public int[] countBits(int num) {
-        int result[] = new int[num + 1];
-        int offset = 1;
-        for (int index = 1; index < num + 1; ++index){
-            if (offset * 2 == index){
-                offset *= 2;
-            }
-            result[index] = result[index - offset] + 1;
-        }
-        return result;
+  public int[] countBits(int n) {
+    int[] numofOnes = new int[n + 1];
+    for (int i = 1; i <= n; i++) {
+      numofOnes[i] = numofOnes[i / 2] + i % 2;
     }
+    return numofOnes;
+  }
 }

From 7e9ca1c927a59b724ed5eb8e703ee51795cdefc3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 10:31:35 -0800
Subject: [PATCH 0818/2175] Rename Medium/Counting Bits.java to Easy/Counting
 Bits.java

---
 {Medium => Easy}/Counting Bits.java | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {Medium => Easy}/Counting Bits.java (100%)

diff --git a/Medium/Counting Bits.java b/Easy/Counting Bits.java
similarity index 100%
rename from Medium/Counting Bits.java
rename to Easy/Counting Bits.java

From ed5210f163c2cb9c7f27cc074f7626b9db6037bf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 10:40:39 -0800
Subject: [PATCH 0819/2175] Update Clone N-ary Tree.java

---
 Medium/Clone N-ary Tree.java | 42 ++++++++++--------------------------
 1 file changed, 11 insertions(+), 31 deletions(-)

diff --git a/Medium/Clone N-ary Tree.java b/Medium/Clone N-ary Tree.java
index 3943e23c..819cb14d 100644
--- a/Medium/Clone N-ary Tree.java	
+++ b/Medium/Clone N-ary Tree.java	
@@ -24,43 +24,23 @@ public Node(int _val,ArrayList<Node> _children) {
 class Solution {
   public Node cloneTree(Node root) {
     if (root == null) {
-      return null;
+      return root;
     }
-    Node copy = new Node(root.val);
-    for (Node child : root.children) {
-      copy.children.add(cloneTree(child));
-    }
-    return copy;
-  }
-
-  Map<Node, Node> map;
-  public Node cloneTreeDetailed(Node root) {
-    if (root == null) {
-      return null;
-    }
-    map = new HashMap<>();
-    copyTree(root);
     Queue<Node> queue = new LinkedList<>();
+    Map<Node, Node> map = new HashMap<>();
     queue.add(root);
+    map.put(root, new Node(root.val));
     while (!queue.isEmpty()) {
-      Node removed = queue.remove();
-      Node copy = map.get(removed);
-      List<Node> children = removed.children;
-      for (Node child : children) {
-        copy.children.add(map.get(child));
-        queue.add(child);
+      int size = queue.size();
+      while (size-- > 0) {
+        Node removed = queue.remove();
+        for (Node child : removed.children) {
+          queue.add(child);
+          map.put(child, new Node(child.val));
+          map.get(removed).children.add(map.get(child));
+        }
       }
     }
     return map.get(root);
   }
-  
-  private void copyTree(Node root) {
-    if (root == null) {
-      return;
-    }
-    map.put(root, new Node(root.val));
-    for (Node child : root.children) {
-      copyTree(child);
-    }
-  }
 }

From 2b395e27d0d45e12c47608df499b9c9585bab07f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 14:14:32 -0800
Subject: [PATCH 0820/2175] Create Product of Two Run-Length Encoded
 Arrays.java

---
 ...duct of Two Run-Length Encoded Arrays.java | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Medium/Product of Two Run-Length Encoded Arrays.java

diff --git a/Medium/Product of Two Run-Length Encoded Arrays.java b/Medium/Product of Two Run-Length Encoded Arrays.java
new file mode 100644
index 00000000..7aa0b117
--- /dev/null
+++ b/Medium/Product of Two Run-Length Encoded Arrays.java	
@@ -0,0 +1,39 @@
+class Solution {
+  public List<List<Integer>> findRLEArray(int[][] encoded1, int[][] encoded2) {
+    int idxOne = 0;
+    int idxTwo = 0;
+    List<List<Integer>> result = new ArrayList<>();
+    while (idxOne < encoded1.length && idxTwo < encoded2.length) {
+      int valueOne = encoded1[idxOne][0];
+      int frequencyOne = 0;
+      while (idxOne < encoded1.length && encoded1[idxOne][0] == valueOne) {
+        frequencyOne += encoded1[idxOne++][1];
+      }
+      idxOne--;
+      encoded1[idxOne][1] = frequencyOne;
+      int valueTwo = encoded2[idxTwo][0];
+      int frequencyTwo = 0;
+      while (idxTwo < encoded2.length && encoded2[idxTwo][0] == valueTwo) {
+        frequencyTwo += encoded2[idxTwo++][1];
+      }
+      idxTwo--;
+      encoded2[idxTwo][1] = frequencyTwo;
+      int prod = encoded1[idxOne][0] * encoded2[idxTwo][0];
+      int frequency = Math.min(encoded1[idxOne][1], encoded2[idxTwo][1]);
+      if (result.size() > 0 && result.get(result.size() - 1).get(0) == prod) {
+        result.get(result.size() - 1).set(1, result.get(result.size() - 1).get(1) + frequency);
+      } else {
+        result.add(Arrays.asList(prod, frequency));
+      }
+      encoded1[idxOne][1] -= frequency;
+      encoded2[idxTwo][1] -= frequency;
+      if (encoded1[idxOne][1] == 0) {
+        idxOne++;
+      }
+      if (encoded2[idxTwo][1] == 0) {
+        idxTwo++;
+      }
+    }
+    return result;
+  }
+}

From 2f5425b77899711e508d667a6d7ce3642c6d07e7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 15:15:23 -0800
Subject: [PATCH 0821/2175] Update Shortest Word Distance III.java

---
 Medium/Shortest Word Distance III.java | 45 ++++++--------------------
 1 file changed, 10 insertions(+), 35 deletions(-)

diff --git a/Medium/Shortest Word Distance III.java b/Medium/Shortest Word Distance III.java
index f2b40359..ba7216c1 100644
--- a/Medium/Shortest Word Distance III.java	
+++ b/Medium/Shortest Word Distance III.java	
@@ -1,40 +1,15 @@
 class Solution {
-  public int shortestWordDistance(String[] words, String word1, String word2) {
-    int idx1 = -1;
-    int idx2 = -1;
-    boolean sameWord = word1.equals(word2);
-    int n = words.length;
-    int minDiff = Integer.MAX_VALUE;
-    for (int i = 0; i < words.length; i++) {
-      if (words[i].equals(word1)) {
-        if (sameWord) {
-          if (idx1 == -1) {
-            idx1 = i;
-          }
-        }
-        else {
-          idx1 = i;
-        }
-      }
-      if (words[i].equals(word2)) {
-        if (sameWord) {
-          if (idx1 != i) {
-            idx2 = i;
-          }
-        }
-        else {
-          idx2 = i;
-        }
-      }
-      if (idx1 != -1 && idx2 != -1) {
-        minDiff = Math.min(minDiff, Math.abs(idx1 - idx2));
-        if (sameWord) {
-          idx1 = idx2;
-          idx2 = -1;
-        }
+  public int shortestWordDistance(String[] wordsDict, String word1, String word2) {
+    int minIdxDiff = wordsDict.length;
+    int prevIdx = -1;
+    for (int i = 0; i < wordsDict.length; i++) {
+      if (wordsDict[i].equals(word1) || wordsDict[i].equals(word2)) {
+        if (prevIdx != -1 && (word1.equals(word2) || !wordsDict[prevIdx].equals(wordsDict[i]))) {
+          minIdxDiff = Math.min(minIdxDiff, Math.abs(prevIdx - i));
+        }
+        prevIdx = i;
       }
     }
-    return minDiff;
+    return minIdxDiff;
   }
 }
-

From 0894420c3dc60386d3ae3404903576e059df9f56 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 16:25:41 -0800
Subject: [PATCH 0822/2175] Update Is Subsequence.java

---
 Easy/Is Subsequence.java | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/Easy/Is Subsequence.java b/Easy/Is Subsequence.java
index fc28d621..90732379 100644
--- a/Easy/Is Subsequence.java	
+++ b/Easy/Is Subsequence.java	
@@ -1,15 +1,11 @@
 class Solution {
   public boolean isSubsequence(String s, String t) {
-    int idxS = 0;
-    int idxT = 0;
-    int lenS = s.length();
-    int lenT = t.length();
-    while (idxS < lenS && idxT < lenT) {
-      if (s.charAt(idxS) == t.charAt(idxT)) {
-        idxS++;
+    int j = 0;
+    for (int i = 0; i < t.length() && j < s.length(); i++) {
+      if (s.charAt(j) == t.charAt(i)) {
+        j++;
       }
-      idxT++;
     }
-    return idxS == lenS;
+    return j == s.length();
   }
 }

From 121fb9f9a4594cb9418a08101c03efd8cd9ddb17 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 16:25:48 -0800
Subject: [PATCH 0823/2175] Delete Is Subsequence.java

---
 Medium/Is Subsequence.java | 21 ---------------------
 1 file changed, 21 deletions(-)
 delete mode 100644 Medium/Is Subsequence.java

diff --git a/Medium/Is Subsequence.java b/Medium/Is Subsequence.java
deleted file mode 100644
index cde06c72..00000000
--- a/Medium/Is Subsequence.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-    public boolean isSubsequence(String s, String t) {
-        char[] sChar = s.toCharArray();
-        char[] tChar = t.toCharArray();
-        
-        int i=0;
-        int j=0;
-        int low = s.length();
-        int high = t.length();
-        
-        while(i<low && j<high) {
-            if (sChar[i] == tChar[j]) {
-                i++;
-            }
-            
-            j++;
-        }
-        
-        return i == low;
-    }
-}

From 8fb887fb1ac60ec9a91e93fce37da14549cfa8f5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Mar 2022 18:56:32 -0800
Subject: [PATCH 0824/2175] Update Number of Matching Subsequences.java

---
 Medium/Number of Matching Subsequences.java | 38 +++++++++++++--------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/Medium/Number of Matching Subsequences.java b/Medium/Number of Matching Subsequences.java
index 8de23b10..aa974e8f 100644
--- a/Medium/Number of Matching Subsequences.java	
+++ b/Medium/Number of Matching Subsequences.java	
@@ -1,23 +1,33 @@
 class Solution {
   public int numMatchingSubseq(String s, String[] words) {
-    int count = 0;
-    for (String word : words) {
-      if (isSubsequence(s, word)) {
-        count++;
+    Map<Character, List<Pair>> map = new HashMap<>();
+    for (int i = 0; i < words.length; i++) {
+      map.computeIfAbsent(words[i].charAt(0), k -> new ArrayList<>()).add(new Pair(0, i));
+    }
+    int counter = 0;
+    for (char c : s.toCharArray()) {
+      List<Pair> existingPairs = map.getOrDefault(c, new ArrayList<>());
+      map.put(c, new ArrayList<>());
+      for (Pair pair : existingPairs) {
+        int currIdx = pair.currIdx;
+        if (currIdx + 1 == words[pair.wordIdx].length()) {
+          counter++;
+        } else {
+          map.computeIfAbsent(words[pair.wordIdx].charAt(currIdx + 1), k -> new ArrayList<>())
+              .add(new Pair(currIdx + 1, pair.wordIdx));
+        }
       }
     }
-    return count;
+    return counter;
   }
+  
+  private static class Pair {
+    int currIdx;
+    int wordIdx;
 
-  private boolean isSubsequence(String s, String word) {
-    int prevIdx = 0;
-    for (char c : word.toCharArray()) {
-      int idx = s.indexOf(c, prevIdx);
-      if (idx == -1) {
-        return false;
-      }
-      prevIdx = idx + 1;
+    public Pair(int currIdx, int wordIdx) {
+      this.currIdx = currIdx;
+      this.wordIdx = wordIdx;
     }
-    return true;
   }
 }

From 5cb844ae2f522e7cbead60fc02c1446116293607 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 2 Mar 2022 10:19:04 -0800
Subject: [PATCH 0825/2175] Update Reverse Words in a String II.java

---
 Medium/Reverse Words in a String II.java | 41 +++++++++++-------------
 1 file changed, 18 insertions(+), 23 deletions(-)

diff --git a/Medium/Reverse Words in a String II.java b/Medium/Reverse Words in a String II.java
index 1931ba7d..c3ce706c 100644
--- a/Medium/Reverse Words in a String II.java	
+++ b/Medium/Reverse Words in a String II.java	
@@ -1,27 +1,22 @@
 class Solution {
-    public static void reverseWords(char[] str) {
-        reverse(str, 0, str.length);
-
-        int start = 0;
-        for (int i=0; i<str.length; i++) {
-            if (str[i] == ' ') {
-                reverse(str, start, i);
-                start = i + 1;
-            }
-        }
-
-        reverse(str, start, str.length);
+  public void reverseWords(char[] s) {
+    reverse(s, 0, s.length - 1);
+    int startIdx = 0;
+    for (int i = 0; i < s.length; i++) {
+      if (s[i] == ' ' || i == s.length - 1) {
+        reverse(s, startIdx, (i == s.length - 1 ? i : i - 1));
+        startIdx = i + 1;
+      }
     }
-
-    private static void reverse(char[] str, int start, int end) {
-        for (int i=0; i<(end - start)/2; i++) {
-            swap(str, start+i, end-i-1);
-        }
-    }
-
-    private static void swap(char[] str, int i, int j) {
-        char temp = str[i];
-        str[i] = str[j];
-        str[j] = temp;
+  }
+  
+  private void reverse(char[] s, int startIdx, int endIdx) {
+    while (startIdx < endIdx) {
+      char temp = s[startIdx];
+      s[startIdx] = s[endIdx];
+      s[endIdx] = temp;
+      startIdx++;
+      endIdx--;
     }
+  }
 }

From 4daa9689519c8040f0112541f95a0415931d135d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 2 Mar 2022 10:27:52 -0800
Subject: [PATCH 0826/2175] Update Binary Tree Upside Down.java

---
 Medium/Binary Tree Upside Down.java | 52 ++++++++++++++---------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/Medium/Binary Tree Upside Down.java b/Medium/Binary Tree Upside Down.java
index dde329cc..b93f1b75 100644
--- a/Medium/Binary Tree Upside Down.java	
+++ b/Medium/Binary Tree Upside Down.java	
@@ -4,35 +4,35 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode upsideDownBinaryTree(TreeNode root) {
-        if (root == null || root.left == null) {
-            return root;
-        }
-        
-        TreeNode left = root.left;
-        TreeNode right = root.right;
-        
-        root.left = null;
-        root.right = null;
-        
-        return helper(left, root, right);
+  public TreeNode upsideDownBinaryTree(TreeNode root) {
+    if (root == null || root.left == null) {
+      return root;
     }
-    
-    private TreeNode helper(TreeNode rootLeft, TreeNode root, TreeNode rootRight) {
-        if (rootLeft == null) {
-            return root;
-        }
-        
-        TreeNode rootLeftLeft = rootLeft.left;
-        TreeNode rootLeftRight = rootLeft.right;
-        
-        rootLeft.left = rootRight;
-        rootLeft.right = root;
-        
-        return helper(rootLeftLeft, rootLeft, rootLeftRight);
+    TreeNode rightNode = root.right;
+    TreeNode leftNode = root.left;
+    root.left = null;
+    root.right = null;
+    return helper(root, leftNode, rightNode);
+  }
+  
+  private TreeNode helper(TreeNode root, TreeNode leftNode, TreeNode rightNode) {
+    if (leftNode == null) {
+      return root;
     }
+    TreeNode leftNodeLeft = leftNode.left;
+    TreeNode leftNodeRight = leftNode.right;
+    leftNode.left = rightNode;
+    leftNode.right = root;
+    return helper(leftNode, leftNodeLeft, leftNodeRight);
+  }
 }

From f5d67d97ea831f677df1603b88978ed41a081202 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 2 Mar 2022 12:48:54 -0800
Subject: [PATCH 0827/2175] Update Accounts Merge.java

---
 Medium/Accounts Merge.java | 48 +++++++++++++++++++-------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/Medium/Accounts Merge.java b/Medium/Accounts Merge.java
index caa718e8..97b55568 100644
--- a/Medium/Accounts Merge.java	
+++ b/Medium/Accounts Merge.java	
@@ -1,38 +1,38 @@
 class Solution {
   public List<List<String>> accountsMerge(List<List<String>> accounts) {
-    Map<String, String> emailToNameMap = new HashMap<>();
-    Map<String, Set<String>> graph = new HashMap<>();
+    Map<String, List<String>> adjacencyList = new HashMap<>();
     for (List<String> account : accounts) {
-      String name = account.get(0);
-      for (int i = 1; i < account.size(); i++) {
-        emailToNameMap.put(account.get(i), name);
-        graph.computeIfAbsent(account.get(i), k -> new HashSet<>()).add(account.get(1));
-        graph.computeIfAbsent(account.get(1), k -> new HashSet<>()).add(account.get(i));
+      String firstEmail = account.get(1);
+      for (int i = 2; i < account.size(); i++) {
+        adjacencyList.computeIfAbsent(firstEmail, k -> new ArrayList<>()).add(account.get(i));
+        adjacencyList.computeIfAbsent(account.get(i), k -> new ArrayList<>()).add(firstEmail);
       }
     }
-    Set<String> seen = new HashSet<>();
-    List<List<String>> ans = new ArrayList<>();
-    for (String email : graph.keySet()) {
-      if (!seen.contains(email)) {
-        seen.add(email);
+    Set<String> visited = new HashSet<>();
+    List<List<String>> mergedAccounts = new ArrayList<>();
+    for (List<String> account : accounts) {
+      String name = account.get(0);
+      String firstEmail = account.get(1);
+      if (!visited.contains(firstEmail)) {
         Stack<String> stack = new Stack<>();
-        stack.push(email);
-        List<String> component = new ArrayList<>();
+        stack.push(firstEmail);
+        List<String> mergedAccount = new ArrayList<>();
+        mergedAccount.add(name);
         while (!stack.isEmpty()) {
-          String node = stack.pop();
-          component.add(node);
-          for (String neighbour : graph.get(node)) {
-            if (!seen.contains(neighbour)) {
-              seen.add(neighbour);
-              stack.push(neighbour);
+          String removedEmail = stack.pop();
+          visited.add(removedEmail);
+          mergedAccount.add(removedEmail);
+          for (String neighbor : adjacencyList.getOrDefault(removedEmail, new ArrayList<>())) {
+            if (!visited.contains(neighbor)) {
+              visited.add(neighbor);
+              stack.push(neighbor);
             }
           }
         }
-        Collections.sort(component);
-        component.add(0, emailToNameMap.get(email));
-        ans.add(component);
+        Collections.sort(mergedAccount.subList(1, mergedAccount.size()));
+        mergedAccounts.add(mergedAccount);
       }
     }
-    return ans;
+    return mergedAccounts;
   }
 }

From 66a9eeb5912acc1c24fc287e3021c1fb2a612cd9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 2 Mar 2022 14:20:35 -0800
Subject: [PATCH 0828/2175] Update 01 Matrix.java

---
 Medium/01 Matrix.java | 65 +++++++++++++++++++------------------------
 1 file changed, 29 insertions(+), 36 deletions(-)

diff --git a/Medium/01 Matrix.java b/Medium/01 Matrix.java
index 8892b6fc..1faa99d0 100644
--- a/Medium/01 Matrix.java	
+++ b/Medium/01 Matrix.java	
@@ -1,40 +1,33 @@
-public class Solution {
-    public int[][] updateMatrix(int[][] matrix) {
-        int m = matrix.length;
-        int n = matrix[0].length;
-        
-        Queue<int[]> queue = new LinkedList<>();
-        for (int i = 0; i < m; i++) {
-            for (int j = 0; j < n; j++) {
-                if (matrix[i][j] == 0) {
-                    queue.offer(new int[] {i, j});
-                }
-                else {
-                    matrix[i][j] = Integer.MAX_VALUE;
-                }
-            }
+class Solution {
+  private static final int[][] DIRS = {{1, 0},  {0, 1}, {-1, 0}, {0, -1}};
+
+  public int[][] updateMatrix(int[][] mat) {
+    int numRows = mat.length;
+    int numCols = mat[0].length;
+    int[][] distances = new int[numRows][numCols];
+    Queue<int[]> queue = new LinkedList<>();
+    for (int i = 0; i < numRows; i++) {
+      for (int j = 0; j < numCols; j++) {
+        if (mat[i][j] == 0) {
+          queue.add(new int[]{i, j});
+        } else {
+          distances[i][j] = Integer.MAX_VALUE;
         }
-        
-        int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
-        
-        while (!queue.isEmpty()) {
-            int[] cell = queue.poll();
-            for (int[] d : dirs) {
-                int r = cell[0] + d[0];
-                int c = cell[1] + d[1];
-                if (r < 0 || 
-                    r >= m || 
-                    c < 0 || 
-                    c >= n || 
-                    matrix[r][c] <= matrix[cell[0]][cell[1]] + 1) {
-                    continue;
-                }
-                
-                queue.add(new int[] {r, c});
-                matrix[r][c] = matrix[cell[0]][cell[1]] + 1;
-            }
+      }
+    }
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int currX = removed[0];
+      int currY = removed[1];
+      for (int[] dir : DIRS) {
+        int newX = currX + dir[0];
+        int newY = currY + dir[1];
+        if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && distances[newX][newY] > distances[currX][currY] + 1) {
+          queue.add(new int[]{newX, newY});
+          distances[newX][newY] = distances[currX][currY] + 1;
         }
-        
-        return matrix;
+      }
     }
+    return distances;
+  }
 }

From 0d8f89f2d9ffc25ac7a6e6ab4183a0fcbe262252 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 2 Mar 2022 16:17:01 -0800
Subject: [PATCH 0829/2175] Update Arithmetic Slices.java

---
 Medium/Arithmetic Slices.java | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/Medium/Arithmetic Slices.java b/Medium/Arithmetic Slices.java
index 3a9b3cd2..0b620a90 100644
--- a/Medium/Arithmetic Slices.java	
+++ b/Medium/Arithmetic Slices.java	
@@ -1,15 +1,13 @@
 class Solution {
-  public int numberOfArithmeticSlices(int[] A) {
-    int counter = 0;
-    int n = A.length;
-    for (int i = 0; i < n - 2; i++) {
-      int diff = A[i + 1] - A[i];
-      int nextIdx = i + 2;
-      while (nextIdx < n && A[nextIdx] - A[nextIdx - 1] == diff) {
-        nextIdx++;
+  public int numberOfArithmeticSlices(int[] nums) {
+    int[] dp = new int[nums.length];
+    int count = 0;
+    for (int i = 2; i < dp.length; i++) {
+      if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) {
+        dp[i] = dp[i - 1] + 1;
+        count += dp[i];
       }
-      counter += nextIdx - i - 2;
     }
-    return counter;
+    return count;
   }
 }

From d76d4f66528d39c80c6651fcd2ce2259a5472c8a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Mar 2022 06:28:26 -0800
Subject: [PATCH 0830/2175] Update Random Pick With Weight.java

---
 Medium/Random Pick With Weight.java | 34 +++++++++++++++++------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/Medium/Random Pick With Weight.java b/Medium/Random Pick With Weight.java
index 3d3546fa..e620ec63 100644
--- a/Medium/Random Pick With Weight.java	
+++ b/Medium/Random Pick With Weight.java	
@@ -1,24 +1,30 @@
 class Solution {
-  int[] arr;
-  int counter = 0;
-  Random r = new Random();
+  private int[] prefixSum;
+  private int totalPrefixSum;
+  
   public Solution(int[] w) {
-    arr = new int[w.length];
-    counter += w[0];
-    arr[0] = w[0];
-    for (int i = 1; i < w.length; i++) {
-      arr[i] = arr[i - 1] + w[i];
-      counter += w[i];
+    this.prefixSum = new int[w.length];
+    int currPrefixSum = 0;
+    for (int i = 0; i < w.length; i++) {
+      currPrefixSum += w[i];
+      this.prefixSum[i] = currPrefixSum;
     }
+    this.totalPrefixSum = currPrefixSum;
   }
 
   public int pickIndex() {
-    int idx = r.nextInt(counter) + 1;
-    int ret = Arrays.binarySearch(arr, idx); 
-    if(ret < 0) {
-      ret = -ret - 1;
+    double randomTarget = this.totalPrefixSum * Math.random();
+    int left = 0;
+    int right = this.prefixSum.length;
+    while (left < right) {
+      int mid = left + (right - left) / 2;
+      if (randomTarget > this.prefixSum[mid]) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
     }
-    return ret;
+    return left;
   }
 }
 

From 8dd11a31dbfcffbf20029e24eb89c12834ef3d88 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Mar 2022 08:05:09 -0800
Subject: [PATCH 0831/2175] Create Pow(x, n).java

---
 Medium/Pow(x, n).java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Pow(x, n).java

diff --git a/Medium/Pow(x, n).java b/Medium/Pow(x, n).java
new file mode 100644
index 00000000..541772af
--- /dev/null
+++ b/Medium/Pow(x, n).java	
@@ -0,0 +1,11 @@
+class Solution {
+  public double myPow(double x, int n) {
+    if (n == 0) {
+      return 1;
+    }
+    if (n < 0) {
+      return 1 / x * myPow(1 / x, -1 * (n + 1));
+    }
+    return n % 2 == 0 ? myPow(x * x, n / 2) : x * myPow(x * x, n / 2);
+  }
+}

From f0e29f2f4b94af5fdd54a0b33b9304423c0f4523 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Mar 2022 08:41:54 -0800
Subject: [PATCH 0832/2175] Update Copy List with Random Pointer.java

---
 Medium/Copy List with Random Pointer.java | 41 ++++++++++++++++++-----
 1 file changed, 33 insertions(+), 8 deletions(-)

diff --git a/Medium/Copy List with Random Pointer.java b/Medium/Copy List with Random Pointer.java
index 333941a2..071731bc 100644
--- a/Medium/Copy List with Random Pointer.java	
+++ b/Medium/Copy List with Random Pointer.java	
@@ -15,19 +15,44 @@ public Node(int val) {
 
 class Solution {
   public Node copyRandomList(Node head) {
-    Map<Node, Node> map = new HashMap<>();
+    if (head == null) {
+      return head;
+    }
     Node curr = head;
+    /*
+    List A->B->C
+    Expected outcome: A->A`->B->B`->C->C` 
+    Where node marked with ` is copied node
+    */
     while (curr != null) {
-      map.put(curr, new Node(curr.val));
-      curr = curr.next;
+      Node newNode = new Node(curr.val);
+      newNode.next = curr.next;
+      curr.next = newNode; 
+      curr = newNode.next;
     }
     curr = head;
+    /*
+    List A->A`->B->B`->C->C`
+         |      |      | (Random pointers)
+         C      A      B
+    Expected outcome: A->A`->B->B`->C->C`
+                      |  |   |  |   |  |
+                      C  C`  A  A`  B  B`
+    */
     while (curr != null) {
-      Node temp = map.get(curr);
-      temp.next = curr.next == null ? null : map.get(curr.next);
-      temp.random = curr.random == null ? null : map.get(curr.random);
-      curr = curr.next;
+      curr.next.random = curr.random != null ? curr.random.next : null;
+      curr = curr.next.next;
+    }
+    Node oldCurr = head;
+    Node newCurr = head.next;
+    Node newHead = head.next; // Retain a pointer to copied list's head
+    // Separate merged lists into original list & copied list.
+    while (oldCurr != null) {
+      oldCurr.next = oldCurr.next.next;
+      newCurr.next = newCurr.next != null ? newCurr.next.next : null;
+      oldCurr = oldCurr.next;
+      newCurr = newCurr.next;
     }
-    return map.get(head);
+    return newHead;
   }
 }

From 7de0f7cab850ae8a21f8f4efe0411ec4cb9dd531 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Mar 2022 14:57:58 -0800
Subject: [PATCH 0833/2175] Update Symmetric Tree.java

---
 Easy/Symmetric Tree.java | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Easy/Symmetric Tree.java b/Easy/Symmetric Tree.java
index c50a5256..b20e39a5 100644
--- a/Easy/Symmetric Tree.java	
+++ b/Easy/Symmetric Tree.java	
@@ -4,27 +4,27 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
- */
+*/
 class Solution {
   public boolean isSymmetric(TreeNode root) {
-    if (root == null) {
-      return true;
-    }
     return helper(root.left, root.right);
   }
   
-  private boolean helper(TreeNode r, TreeNode l) {
-    if (r == null && l == null) {
+  private boolean helper(TreeNode leftNode, TreeNode rightNode) {
+    if (leftNode == null && rightNode == null) {
       return true;
     }
-    if (r == null || l == null) {
-      return false;
-    }
-    if (r.val != l.val) {
+    if ((leftNode == null || rightNode == null) || leftNode.val != rightNode.val) {
       return false;
     }
-    return helper(l.left, r.right) && helper(l.right, r.left);
+    return helper(leftNode.left, rightNode.right) && helper(leftNode.right, rightNode.left);
   }
 }

From 1fede887488542a204ee8282abd830b29af496f3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Mar 2022 16:49:22 -0800
Subject: [PATCH 0834/2175] Update Valid Palindrome.java

---
 Easy/Valid Palindrome.java | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/Easy/Valid Palindrome.java b/Easy/Valid Palindrome.java
index 255d45ee..11b2358a 100644
--- a/Easy/Valid Palindrome.java	
+++ b/Easy/Valid Palindrome.java	
@@ -1,25 +1,23 @@
 class Solution {
   public boolean isPalindrome(String s) {
-    int start = 0;
-    int end = s.length() - 1;
-    while (start < end) {
-      if (Character.isLetterOrDigit(s.charAt(start)) && Character.isLetterOrDigit(s.charAt(end))) {
-        char c1 = Character.isLetter(s.charAt(start)) ? Character.toLowerCase(s.charAt(start)) : s.charAt(start);
-        char c2 = Character.isLetter(s.charAt(end)) ? Character.toLowerCase(s.charAt(end)) : s.charAt(end);
-        if (c1 != c2) {
-          return false;
-        }
-        start++;
-        end--;
+    int startIdx = 0;
+    int endIdx = s.length() - 1;
+    while (startIdx < endIdx) {
+      if (!Character.isLetterOrDigit(s.charAt(startIdx))) {
+        startIdx++;
+        continue;
       }
-      else {
-        if (!Character.isLetterOrDigit(s.charAt(start))) {
-          start++;
-        }
-        if (!Character.isLetterOrDigit(s.charAt(end))) {
-          end--;
-        }
+      if (!Character.isLetterOrDigit(s.charAt(endIdx))) {
+        endIdx--;
+        continue;
       }
+      char startChar = Character.isDigit(s.charAt(startIdx)) ? s.charAt(startIdx) : Character.toLowerCase(s.charAt(startIdx));
+      char endChar = Character.isDigit(s.charAt(endIdx)) ? s.charAt(endIdx) : Character.toLowerCase(s.charAt(endIdx));
+      if (startChar != endChar) {
+        return false;
+      }
+      startIdx++;
+      endIdx--;
     }
     return true;
   }

From d78c7f03633ec3e338d12a8876a6ae38b1c07564 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Mar 2022 20:18:48 -0800
Subject: [PATCH 0835/2175] Update Add Strings.java

---
 Easy/Add Strings.java | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/Easy/Add Strings.java b/Easy/Add Strings.java
index 6a68a142..16cf5461 100644
--- a/Easy/Add Strings.java	
+++ b/Easy/Add Strings.java	
@@ -1,21 +1,19 @@
 class Solution {
   public String addStrings(String num1, String num2) {
+    int carry = 0;
     StringBuilder sb = new StringBuilder();
     int idxOne = num1.length() - 1;
     int idxTwo = num2.length() - 1;
-    int carry = 0;
     while (idxOne >= 0 || idxTwo >= 0 || carry > 0) {
-      int temp = carry;
       if (idxOne >= 0 && idxTwo >= 0) {
-        temp += Character.getNumericValue(num1.charAt(idxOne--)) + Character.getNumericValue(num2.charAt(idxTwo--));
+        carry += Character.getNumericValue(num1.charAt(idxOne--)) + Character.getNumericValue(num2.charAt(idxTwo--));
       } else if (idxOne >= 0 && idxTwo < 0) {
-        temp += Character.getNumericValue(num1.charAt(idxOne--));
+        carry += Character.getNumericValue(num1.charAt(idxOne--));
       } else if (idxOne < 0 && idxTwo >= 0) {
-        temp += Character.getNumericValue(num2.charAt(idxTwo--));
+        carry += Character.getNumericValue(num2.charAt(idxTwo--));
       }
-      carry = temp > 9 ? 1 : 0;
-      temp = temp > 9 ? temp % 10 : temp;
-      sb.append(temp);
+      sb.append(carry % 10);
+      carry = carry > 9 ? carry / 10 : 0;
     }
     return sb.reverse().toString();
   }

From 662129817709ef8254ea6298577296f78553b9f5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 4 Mar 2022 12:33:08 -0800
Subject: [PATCH 0836/2175] Update Basic Calculator II.java

---
 Medium/Basic Calculator II.java | 42 ++++++++++++++++++++-------------
 1 file changed, 26 insertions(+), 16 deletions(-)

diff --git a/Medium/Basic Calculator II.java b/Medium/Basic Calculator II.java
index 470ec88c..402e394c 100644
--- a/Medium/Basic Calculator II.java	
+++ b/Medium/Basic Calculator II.java	
@@ -1,25 +1,16 @@
 class Solution {
   public int calculate(String s) {
-    int num = 0;
     char sign = '+';
+    int currNum = 0;
     Stack<Integer> stack = new Stack<>();
     for (int i = 0; i < s.length(); i++) {
-      char c = s.charAt(i);
-      if (Character.isDigit(c)) {
-        num = num * 10 + Character.getNumericValue(c);
+      if (Character.isDigit(s.charAt(i))) {
+        currNum = currNum * 10 + Character.getNumericValue(s.charAt(i));
       } 
-      if (!Character.isDigit(c) && c != ' ' || i == s.length() - 1) {
-        if (sign == '+') {
-          stack.push(num);
-        } else if (sign == '-') {
-          stack.push(-num);
-        } else if (sign == '*') {
-          stack.push(stack.pop() * num);
-        } else {
-          stack.push(stack.pop() / num);
-        }
-        sign = c;
-        num = 0;
+      if ((!Character.isDigit(s.charAt(i)) && s.charAt(i) != ' ') || i == s.length() - 1) {
+        updateStackForPreviousSign(sign, stack, currNum);
+        currNum = 0;
+        sign = s.charAt(i);
       }
     }
     int result = 0;
@@ -28,4 +19,23 @@ public int calculate(String s) {
     }
     return result;
   }
+
+  private void updateStackForPreviousSign(char sign, Stack<Integer> stack, int currNum) {
+    switch (sign) {
+      case '+':
+        stack.push(currNum);
+        break;
+      case '-':
+        stack.push(-1 * currNum);
+        break;
+      case '/':
+        stack.push(stack.pop() / currNum);
+        break;
+      case '*':
+        stack.push(stack.pop() * currNum);
+        break;
+      default:
+        break;
+    }
+  }
 }

From 243e1cf42136b11db99a0e8f9bc6b87a857196be Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 5 Mar 2022 07:41:30 -0800
Subject: [PATCH 0837/2175] Update Remove All Adjacent Duplicates In
 String.java

---
 ...ove All Adjacent Duplicates In String.java | 28 +++++++++----------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/Easy/Remove All Adjacent Duplicates In String.java b/Easy/Remove All Adjacent Duplicates In String.java
index e0c7c46d..0eb0caa8 100644
--- a/Easy/Remove All Adjacent Duplicates In String.java	
+++ b/Easy/Remove All Adjacent Duplicates In String.java	
@@ -1,22 +1,20 @@
 class Solution {
-  public String removeDuplicates(String S) {
-    Stack<Integer> stack = new Stack<>();
-    char[] chars = S.toCharArray();
-    for (int i = 0; i < S.length(); i++) {
-      if (stack.isEmpty() || chars[stack.peek()] != chars[i]) {
-        stack.push(i);
-      }
-      else {
-        chars[i] = '-';
-        chars[stack.pop()] = '-';
+  public String removeDuplicates(String s) {
+    Stack<Character> stack = new Stack<>();
+    int idx = 0;
+    while (idx < s.length()) {
+      char c = s.charAt(idx);
+      if (!stack.isEmpty() && stack.peek() == c) {
+        stack.pop();
+      } else {
+        stack.push(c);
       }
+      idx++;
     }
     StringBuilder sb = new StringBuilder();
-    for (char c : chars) {
-      if (c != '-') {
-        sb.append(c);
-      }
+    while (!stack.isEmpty()) {
+      sb.append(stack.pop());
     }
-    return sb.toString();
+    return sb.reverse().toString();
   }
 }

From 9821588700db6cc0adbfb5b81a9b220dfb351525 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 5 Mar 2022 10:01:31 -0800
Subject: [PATCH 0838/2175] Create Most Frequent Number Following Key In an
 Array.java

---
 ...equent Number Following Key In an Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Most Frequent Number Following Key In an Array.java

diff --git a/Easy/Most Frequent Number Following Key In an Array.java b/Easy/Most Frequent Number Following Key In an Array.java
new file mode 100644
index 00000000..4f9b8523
--- /dev/null
+++ b/Easy/Most Frequent Number Following Key In an Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int mostFrequent(int[] nums, int key) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int maxCount = 0;
+    int maxCountCandidate = -1;
+    for (int i = 1; i < nums.length; i++) {
+      if (nums[i - 1] == key) {
+        map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
+        if (map.get(nums[i]) > maxCount) {
+          maxCount = map.get(nums[i]);
+          maxCountCandidate = nums[i];
+        }
+      }
+    }
+    return maxCountCandidate;
+  }
+}

From 1e7c76809afa37f92fac5736ca632f2ca772b49a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Mar 2022 14:32:09 -0800
Subject: [PATCH 0839/2175] Create Cells in a Range on an Excel Sheet.java

---
 Easy/Cells in a Range on an Excel Sheet.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Cells in a Range on an Excel Sheet.java

diff --git a/Easy/Cells in a Range on an Excel Sheet.java b/Easy/Cells in a Range on an Excel Sheet.java
new file mode 100644
index 00000000..8307c2b5
--- /dev/null
+++ b/Easy/Cells in a Range on an Excel Sheet.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public List<String> cellsInRange(String s) {
+    List<String> cells = new ArrayList<>();
+    String[] splits = s.split(":");
+    char startCol = splits[0].charAt(0);
+    int startRow = Character.getNumericValue(splits[0].charAt(1));
+    char endCol = splits[1].charAt(0);
+    int endRow = Character.getNumericValue(splits[1].charAt(1));
+    for (char c = startCol; c <= endCol; c = (char) (c + 1)) {
+      for (int j = startRow; j <= endRow; j++) {
+        cells.add(c + "" + j);
+      }
+    }
+    return cells;
+  }
+}

From 6b3196f272a511b8218bbd072d60204907f00d1c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Mar 2022 15:15:15 -0800
Subject: [PATCH 0840/2175] Create Sort the Jumbled Numbers.java

---
 Medium/Sort the Jumbled Numbers.java | 31 ++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Sort the Jumbled Numbers.java

diff --git a/Medium/Sort the Jumbled Numbers.java b/Medium/Sort the Jumbled Numbers.java
new file mode 100644
index 00000000..83d05724
--- /dev/null
+++ b/Medium/Sort the Jumbled Numbers.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public int[] sortJumbled(int[] mapping, int[] nums) {
+    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((o1, o2) -> {
+      if (o1[0] != o2[0]) {
+        return o1[0] - o2[0];
+      }
+      return o1[1] - o2[1];
+    });
+    for (int i = 0; i < nums.length; i++) {
+      priorityQueue.add(new int[]{getUpdatedNumAfterMapping(nums[i], mapping), i, nums[i]});
+    }
+    for (int i = 0; i < nums.length; i++) {
+      nums[i] = priorityQueue.poll()[2];
+    }
+    return nums;
+  }
+
+  private int getUpdatedNumAfterMapping(Integer original, int[] mapping) {
+    if (original <= 9) {
+      return mapping[original];
+    }
+    int updatedNum = 0;
+    int factor = 1;
+    while (original > 0){
+      updatedNum += mapping[original % 10] * factor;
+      factor *= 10;
+      original /= 10;
+    }
+    return updatedNum;
+  }
+}

From ff067748a089e7793f060f134938d6b0b0db218c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Mar 2022 17:11:01 -0800
Subject: [PATCH 0841/2175] Update Merge Two Sorted Lists.java

---
 Easy/Merge Two Sorted Lists.java | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/Easy/Merge Two Sorted Lists.java b/Easy/Merge Two Sorted Lists.java
index f4b4c5b5..7ce21fbd 100644
--- a/Easy/Merge Two Sorted Lists.java	
+++ b/Easy/Merge Two Sorted Lists.java	
@@ -9,22 +9,26 @@
  * }
  */
 class Solution {
-  public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+  public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
     ListNode dummy = new ListNode(-1);
     ListNode curr = dummy;
-    while (l1 != null || l2 != null) {
-      int val = Math.min(
-        (l1 == null ? Integer.MAX_VALUE : l1.val),
-        (l2 == null ? Integer.MAX_VALUE : l2.val)
-      );
-      curr.next = new ListNode(val);
-      curr = curr.next;
-      if (l1 != null && l1.val == val) {
-        l1 = l1.next;
-      }
-      else {
-        l2 = l2.next;
+    while (list1 != null || list2 != null) {
+      if (list1 != null && list2 != null) {
+        if (list1.val > list2.val) {
+          curr.next = new ListNode(list2.val);
+          list2 = list2.next;
+        } else {
+          curr.next = new ListNode(list1.val);
+          list1 = list1.next;
+        }
+      } else if (list1 != null && list2 == null) {
+        curr.next = new ListNode(list1.val);
+        list1 = list1.next;
+      } else {
+        curr.next = new ListNode(list2.val);
+        list2 = list2.next;
       }
+      curr = curr.next;
     }
     return dummy.next;
   }

From 075068c9d5c3f321a5464361a4506b33b14168c3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Mar 2022 06:50:16 -0800
Subject: [PATCH 0842/2175] Create Append K Integers With Minimal Sum.java

---
 .../Append K Integers With Minimal Sum.java   | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Append K Integers With Minimal Sum.java

diff --git a/Medium/Append K Integers With Minimal Sum.java b/Medium/Append K Integers With Minimal Sum.java
new file mode 100644
index 00000000..bea57e93
--- /dev/null
+++ b/Medium/Append K Integers With Minimal Sum.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public long minimalKSum(int[] nums, int k) {
+    Arrays.sort(nums);
+    long sum = 0;
+    long low = 1;
+    for (int num : nums) {
+      if (num > low) {
+        long high = Math.min(num - 1, low + k - 1);
+        int count = (int) (high - low + 1);
+        sum += (low + high) * count / 2;
+        k -= count;
+        if (k == 0) {
+          return sum;
+        }
+      }
+      low = num + 1;
+    }
+    return sum + (2 * low + k - 1) * k / 2;
+  }
+}

From 3a720a13a00a1886bc50c892fc4b5445411c336d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Mar 2022 07:16:00 -0800
Subject: [PATCH 0843/2175] Create All Ancestors of a Node in a Directed
 Acyclic Graph.java

---
 ...of a Node in a Directed Acyclic Graph.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/All Ancestors of a Node in a Directed Acyclic Graph.java

diff --git a/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java b/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java
new file mode 100644
index 00000000..60ab5900
--- /dev/null
+++ b/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public List<List<Integer>> getAncestors(int n, int[][] edges) {
+    Map<Integer, List<Integer>> graph = new HashMap<>();
+    for (int[] edge : edges) {
+      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    }
+    List<List<Integer>> result = new ArrayList<>();
+    for (int i = 0; i < n; i++) {
+      List<Integer> ancestors = new ArrayList<>();
+      Set<Integer> visited = new HashSet<>();
+      Queue<Integer> queue = new LinkedList<>(graph.getOrDefault(i, new ArrayList<>()));
+      while (!queue.isEmpty()) {
+        int removed = queue.remove();
+        if (visited.contains(removed)) {
+          continue;
+        }
+        ancestors.add(removed);
+        visited.add(removed);
+        queue.addAll(graph.getOrDefault(removed, new ArrayList<>()));
+      }
+      Collections.sort(ancestors);
+      result.add(ancestors);
+    }
+    return result;
+  }
+}

From df7171877b69cf6b733444c23a60d08a85653eaf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Mar 2022 09:10:44 -0800
Subject: [PATCH 0844/2175] Create Create Binary Tree From Descriptions.java

---
 .../Create Binary Tree From Descriptions.java | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/Create Binary Tree From Descriptions.java

diff --git a/Medium/Create Binary Tree From Descriptions.java b/Medium/Create Binary Tree From Descriptions.java
new file mode 100644
index 00000000..bb04e8d2
--- /dev/null
+++ b/Medium/Create Binary Tree From Descriptions.java	
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode createBinaryTree(int[][] descriptions) {
+    Map<Integer, TreeNode> nodeMapping = new HashMap<>();
+    Set<Integer> childNodes = new HashSet<>();
+    for (int[] description : descriptions) {
+      nodeMapping.putIfAbsent(description[0], new TreeNode(description[0]));
+      nodeMapping.putIfAbsent(description[1], new TreeNode(description[1]));
+      if (description[2] == 1) {
+        nodeMapping.get(description[0]).left = nodeMapping.get(description[1]);
+      } else {
+        nodeMapping.get(description[0]).right = nodeMapping.get(description[1]);
+      }
+      childNodes.add(description[1]);
+    }
+    for (Integer key : nodeMapping.keySet()) {
+      if (!childNodes.contains(key)) {
+        return nodeMapping.get(key);
+      }
+    }
+    return null;
+  }
+}

From d04bd6e12bdfd0cd70ad559d49d20337527cbc2b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Mar 2022 13:29:48 -0800
Subject: [PATCH 0845/2175] Update Diagonal Traverse.java

---
 Medium/Diagonal Traverse.java | 74 +++++++++++++----------------------
 1 file changed, 28 insertions(+), 46 deletions(-)

diff --git a/Medium/Diagonal Traverse.java b/Medium/Diagonal Traverse.java
index 0fc4371b..65c991a5 100644
--- a/Medium/Diagonal Traverse.java	
+++ b/Medium/Diagonal Traverse.java	
@@ -1,51 +1,33 @@
 class Solution {
-    public int[] findDiagonalOrder(int[][] matrix) {
-        if (matrix.length == 0 || matrix[0].length == 0) {
-            return new int[]{};
+  public int[] findDiagonalOrder(int[][] matrix) {
+    int dir = 0;
+    int x = 0;
+    int y = 0;
+    int numOfRows = matrix.length;
+    int numOfCols = matrix[0].length;
+    int[] ans = new int[numOfRows * numOfCols];
+    for (int i = 0; i < numOfRows * numOfCols; i++) {
+      ans[i] = matrix[x][y];
+      if ((x + y) % 2 == 0) {
+        if (y == numOfCols - 1) {
+          x++;
+        } else if (x == 0) {
+          y++;
+        } else {
+          x--;
+          y++;
         }
-        
-        int dir = 0;
-        int x = 0;
-        int y = 0;
-        int numOfRows = matrix.length;
-        int numOfCols = matrix[0].length;
-        int[] ans = new int[matrix.length * matrix[0].length];
-        
-        for (int i = 0; i < numOfRows * numOfCols; i++) {
-            ans[i] = matrix[x][y];
-            
-            if ((x + y) % 2 == 0) {
-                // If last column then go to next row
-                if (y == numOfCols - 1) {
-                    x++;
-                }
-                // If first row but not last column then go to next column
-                else if (x == 0) {
-                    y++;
-                }
-                // Go up
-                else {
-                    x--;
-                    y++;
-                }
-            }
-            else {
-                // If last row then go to next column
-                if (x == numOfRows - 1) {
-                    y++;
-                }
-                // If first column but not last row then go to next row
-                else if (y == 0) {
-                    x++;
-                }
-                // Go down
-                else {
-                    x++;
-                    y--;
-                }
-            }
+      } else {
+        if (x == numOfRows - 1) {
+          y++;
+        } else if (y == 0) {
+          x++;
+        } else {
+          x++;
+          y--;
         }
-        
-        return ans;
+      }
     }
+    return ans;
+  }
 }

From 2ea85e40980da972efeade74cc359286e269a68c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Mar 2022 10:42:37 -0800
Subject: [PATCH 0846/2175] Update and rename Medium/Teemo Attacking.java to
 Easy/Teemo Attacking.java

---
 Easy/Teemo Attacking.java   | 11 +++++++++++
 Medium/Teemo Attacking.java | 22 ----------------------
 2 files changed, 11 insertions(+), 22 deletions(-)
 create mode 100644 Easy/Teemo Attacking.java
 delete mode 100644 Medium/Teemo Attacking.java

diff --git a/Easy/Teemo Attacking.java b/Easy/Teemo Attacking.java
new file mode 100644
index 00000000..45e33622
--- /dev/null
+++ b/Easy/Teemo Attacking.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int findPoisonedDuration(int[] timeSeries, int duration) {
+    int totalDuration = 0;
+    int prevTime = timeSeries[0];
+    for (int i = 1; i < timeSeries.length; i++) {
+      totalDuration += Math.min(duration, timeSeries[i] - prevTime);
+      prevTime = timeSeries[i];
+    }
+    return totalDuration + duration;
+  }
+}
diff --git a/Medium/Teemo Attacking.java b/Medium/Teemo Attacking.java
deleted file mode 100644
index f91db3db..00000000
--- a/Medium/Teemo Attacking.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-  public int findPoisonedDuration(int[] timeSeries, int duration) {
-    if (timeSeries.length == 0 || duration <= 0) {
-      return 0;
-    }
-    int totalTimePoisened = 0;
-    int currPoisenedTime = 0;
-    int n = timeSeries.length;
-    for (int i = 0; i < n; i++) {
-      if (currPoisenedTime > 0) {
-        if (currPoisenedTime <= timeSeries[i]) {
-          totalTimePoisened += duration;
-        }
-        else {
-          totalTimePoisened += timeSeries[i] - timeSeries[i - 1];
-        }
-      }
-      currPoisenedTime = timeSeries[i] + duration;
-    }
-    return totalTimePoisened + (currPoisenedTime - timeSeries[n - 1]);
-  }
-}

From 768d27350b8dc43e7b949006433929a1aaf9b2f5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Mar 2022 10:56:11 -0800
Subject: [PATCH 0847/2175] Update Toeplitz Matrix.java

---
 Easy/Toeplitz Matrix.java | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/Easy/Toeplitz Matrix.java b/Easy/Toeplitz Matrix.java
index c5422a95..bccbd515 100644
--- a/Easy/Toeplitz Matrix.java	
+++ b/Easy/Toeplitz Matrix.java	
@@ -1,11 +1,12 @@
 class Solution {
-    public boolean isToeplitzMatrix(int[][] matrix) {
-        for (int i=0;i<matrix.length-1;i++) {
-            for (int j=0;j<matrix[i].length-1;j++) {
-                if (matrix[i][j] != matrix[i+1][j+1]) return false;
-            }
+  public boolean isToeplitzMatrix(int[][] matrix) {
+    for (int i = 0; i < matrix.length - 1; i++) {
+      for (int j = 0; j < matrix[0].length - 1; j++) {
+        if (matrix[i][j] != matrix[i + 1][j + 1]) {
+          return false;
         }
-        
-        return true;
+      }
     }
-}
\ No newline at end of file
+    return true;
+  }
+}

From b96fb2607b623c6a16cfcc9ddf6ec8ec324f0603 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Mar 2022 13:06:10 -0800
Subject: [PATCH 0848/2175] Update Capacity To Ship Packages Within D Days.java

---
 ...pacity To Ship Packages Within D Days.java | 44 ++++++++++---------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/Medium/Capacity To Ship Packages Within D Days.java b/Medium/Capacity To Ship Packages Within D Days.java
index 8b3b587f..8d7ff38e 100644
--- a/Medium/Capacity To Ship Packages Within D Days.java	
+++ b/Medium/Capacity To Ship Packages Within D Days.java	
@@ -1,29 +1,31 @@
 class Solution {
-  public int shipWithinDays(int[] weights, int D) {
-    int maxWeight = weights[0];
-    int totalWeight = 0;
+  public int shipWithinDays(int[] weights, int days) {
+    int maximumWeight = 0;
+    int minimumWeight = weights[0];
     for (int weight : weights) {
-      maxWeight = Math.max(maxWeight, weight);
-      totalWeight += weight;
+      maximumWeight += weight;
+      minimumWeight = Math.max(minimumWeight, weight);
     }
-    while (maxWeight < totalWeight) {
-      int midWeight = (maxWeight + totalWeight) / 2;
-      int need = 1;
-      int curr = 0;
-      for (int weight : weights) {
-        if (curr + weight > midWeight) {
-            need += 1;
-            curr = 0;
-        }
-        curr += weight;
+    while (minimumWeight <= maximumWeight) {
+      int currCapacity = (maximumWeight + minimumWeight) / 2;
+      if (isShipmentPossible(weights, days, currCapacity)) {
+        maximumWeight = currCapacity - 1;
+      } else {
+        minimumWeight = currCapacity + 1;
       }
-      if (need > D) {
-        maxWeight = midWeight + 1;
-      }
-      else {
-        totalWeight = midWeight;
+    }
+    return minimumWeight;
+  }
+
+  private boolean isShipmentPossible(int[] weights, int days, int capacity) {
+    int idx = 0;
+    while (idx < weights.length) {
+      int currWeight = 0;
+      while (idx < weights.length && currWeight + weights[idx] <= capacity) {
+        currWeight += weights[idx++];
       }
+      days--;
     }
-    return maxWeight;
+    return days >= 0;
   }
 }

From ac4498248a48f68ac26e378dd4a474d5cf1a07b7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Mar 2022 13:49:01 -0800
Subject: [PATCH 0849/2175] Update Sum Root to Leaf Numbers.java

---
 Medium/Sum Root to Leaf Numbers.java | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/Medium/Sum Root to Leaf Numbers.java b/Medium/Sum Root to Leaf Numbers.java
index c24f21aa..63179830 100644
--- a/Medium/Sum Root to Leaf Numbers.java	
+++ b/Medium/Sum Root to Leaf Numbers.java	
@@ -16,21 +16,20 @@
 class Solution {
   public int sumNumbers(TreeNode root) {
     int[] sum = {0};
-    helper(root, sum, 0);
+    helper(root, 0, sum);
     return sum[0];
   }
   
-  private void helper(TreeNode node, int[] sum, int currVal) {
-    if (node == null) {
+  private void helper(TreeNode root, int currValue, int[] sum) {
+    if (root == null) {
       return;
     }
-    currVal = currVal * 10 + node.val;
-    if (node.left == null && node.right == null) {
-      sum[0] += currVal;
-    }
-    else {
-      helper(node.left, sum, currVal);
-      helper(node.right, sum, currVal);
+    currValue = currValue * 10 + root.val;
+    if (root.left == null && root.right == null) {
+      sum[0] += currValue;
+      return;
     }
+    helper(root.left, currValue, sum);
+    helper(root.right, currValue, sum);
   }
 }

From 1d654e3ec591078f327c2cbafea395dd8472c55e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Mar 2022 14:37:36 -0800
Subject: [PATCH 0850/2175] Update Verifying an Alien Dictionary.java

---
 Easy/Verifying an Alien Dictionary.java | 29 +++++++++++++------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/Easy/Verifying an Alien Dictionary.java b/Easy/Verifying an Alien Dictionary.java
index ceccf55b..9c71c049 100644
--- a/Easy/Verifying an Alien Dictionary.java	
+++ b/Easy/Verifying an Alien Dictionary.java	
@@ -1,30 +1,31 @@
 class Solution {
   public boolean isAlienSorted(String[] words, String order) {
-    Map<Character, Integer> map = new HashMap<>();
+    Map<Character, Integer> dictionary = new HashMap<>();
     for (int i = 0; i < order.length(); i++) {
-      map.put(order.charAt(i), i);
+      dictionary.put(order.charAt(i), i);
     }
     for (int i = 0; i < words.length - 1; i++) {
-      if (!verifyHelper(words[i], words[i + 1], map)) {
+      if (!hasCorrectOrder(words[i], words[i + 1], dictionary)) {
         return false;
       }
     }
     return true;
   }
   
-  private boolean verifyHelper(String s1, String s2, Map<Character, Integer> map) {
-    int idx1 = 0;
-    int idx2 = 0;
-    while (idx1 < s1.length() && idx2 < s2.length()) {
-      if (map.get(s1.charAt(idx1)) < map.get(s2.charAt(idx2))) {
-        return true;
-      }
-      if (map.get(s1.charAt(idx1)) > map.get(s2.charAt(idx2))) {
+  private boolean hasCorrectOrder(String firstWord, String secondWord, Map<Character, Integer> dictionary) {
+    int idxOne = 0;
+    int idxTwo = 0;
+    boolean correctOrder = false;
+    while (idxOne < firstWord.length() && idxTwo < secondWord.length()) {
+      int dictionaryDiff = dictionary.get(firstWord.charAt(idxOne++)) - dictionary.get(secondWord.charAt(idxTwo++));
+      if (dictionaryDiff > 0) {
         return false;
+      } 
+      if (dictionaryDiff < 0) {
+        correctOrder = true;
+        break;
       }
-      idx1++;
-      idx2++;
     }
-    return s1.length() <= s2.length();
+    return correctOrder || firstWord.length() <= secondWord.length();
   }
 }

From 7b8f8695e76a5e2e19406fadee3aebf505d4137f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Mar 2022 16:15:29 -0800
Subject: [PATCH 0851/2175] Update Remove Duplicates from Sorted List II.java

---
 Medium/Remove Duplicates from Sorted List II.java | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Medium/Remove Duplicates from Sorted List II.java b/Medium/Remove Duplicates from Sorted List II.java
index 62a3b0e3..edb287cc 100644
--- a/Medium/Remove Duplicates from Sorted List II.java	
+++ b/Medium/Remove Duplicates from Sorted List II.java	
@@ -3,27 +3,27 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
   public ListNode deleteDuplicates(ListNode head) {
-    ListNode curr = head;
     ListNode prev = null;
+    ListNode curr = head;
     while (curr != null) {
-      if (curr.next != null && curr.val == curr.next.val) {
+      if (curr.next != null && curr.next.val == curr.val) {
         int currVal = curr.val;
         while (curr != null && curr.val == currVal) {
           curr = curr.next;
         }
         if (prev == null) {
           head = curr;
-        }
-        else {
+        } else {
           prev.next = curr;
         }
-      }
-      else {
+      } else {
         prev = curr;
         curr = curr.next;
       }

From 5ee382ec06979802af8de96737f05abab97d04ca Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Mar 2022 08:11:44 -0800
Subject: [PATCH 0852/2175] Update LRU Cache.java

---
 Hard/LRU Cache.java | 96 ++++++++++++++++++++-------------------------
 1 file changed, 43 insertions(+), 53 deletions(-)

diff --git a/Hard/LRU Cache.java b/Hard/LRU Cache.java
index 2f2c70c0..e141637f 100644
--- a/Hard/LRU Cache.java	
+++ b/Hard/LRU Cache.java	
@@ -1,79 +1,69 @@
 class LRUCache {
-  Node head;
-  Node tail;
-  Map<Integer, Node> map;
-  int capacity;
+
+  private final Map<Integer, Node> map;
+  private final Node head;
+  private final Node tail;
+  private int capacity;
+
   public LRUCache(int capacity) {
-    head = new Node(-1, -1);
-    tail = new Node(-1, -1);
+    this.map = new HashMap<>();
+    this.head = new Node(-1, -1);
+    this.tail = new Node(-1, -1);
     head.next = tail;
     tail.prev = head;
-    map = new HashMap<>();
     this.capacity = capacity;
   }
 
   public int get(int key) {
-    if (!map.containsKey(key)) {
+    if (!this.map.containsKey(key)) {
       return -1;
     }
-    int val = map.get(key).val;
-    moveToFront(map.get(key));
-    return val;
+    Node node = this.map.get(key);
+    removeNode(node);
+    addNode(node);
+    return this.map.get(key).val;
   }
 
   public void put(int key, int value) {
     if (!map.containsKey(key)) {
-      if (map.size() == capacity) {
-        evictKey(tail.prev);
+      if (capacity == 0) {
+        removeNode(tail.prev);
       }
-      Node node = new Node(key, value);
-      map.put(key, node);
-      node.next = head.next;
-      head.next.prev = node;
-      head.next = node;
-      node.prev = head;
-    }
-    else {
-      map.get(key).val = value;
-      moveToFront(map.get(key));
+    } else {
+      removeNode(this.map.get(key));
     }
+    addNode(new Node(key, value));
   }
   
-  private void moveToFront(Node node) {
-    Node prev = node.prev;
-    node.next.prev = prev;
-    prev.next = node.next;
-    node.next = head.next;
-    head.next.prev = node;
-    node.prev = head;
+  private void addNode(Node node) {
+    Node nextToHead = head.next;
     head.next = node;
+    node.next = nextToHead;
+    nextToHead.prev = node;
+    node.prev = head;
+    this.map.put(node.key, node);
+    this.capacity--;
   }
   
-  private void evictKey(Node node) {
-    Node prev = node.prev;
-    node.next.prev = prev;
-    prev.next = node.next;
-    map.remove(node.key);
+  private void removeNode(Node node) {
+    Node nextNode = node.next;
+    node.prev.next = nextNode;
+    nextNode.prev = node.prev;
+    this.map.remove(node.key);
+    this.capacity++;
   }
-}
 
-/**
- * Your LRUCache object will be instantiated and called as such:
- * LRUCache obj = new LRUCache(capacity);
- * int param_1 = obj.get(key);
- * obj.put(key,value);
- */
+  private static class Node {
+    Node next;
+    Node prev;
+    int key;
+    int val;
 
-class Node {
-  int key;
-  int val;
-  Node next;
-  Node prev;
-  
-  public Node(int key, int val) {
-    this.key = key;
-    this.val = val;
-    next = null;
-    prev = null;
+    public Node(int key, int val) {
+      this.key = key;
+      this.val = val;
+      this.next = null;
+      this.prev = null;
+    }
   }
 }

From 8dc4d7ea946d236d3a6bd3edb30caef5253b400e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Mar 2022 08:15:53 -0800
Subject: [PATCH 0853/2175] Rename Hard/LRU Cache.java to Medium/LRU Cache.java

---
 {Hard => Medium}/LRU Cache.java | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {Hard => Medium}/LRU Cache.java (100%)

diff --git a/Hard/LRU Cache.java b/Medium/LRU Cache.java
similarity index 100%
rename from Hard/LRU Cache.java
rename to Medium/LRU Cache.java

From 99e3a52433dec058e8c88f4711e353550c2dc56b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Mar 2022 14:55:30 -0800
Subject: [PATCH 0854/2175] Update Palindromic Substrings.java

---
 Medium/Palindromic Substrings.java | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/Medium/Palindromic Substrings.java b/Medium/Palindromic Substrings.java
index 6532847b..01950841 100644
--- a/Medium/Palindromic Substrings.java	
+++ b/Medium/Palindromic Substrings.java	
@@ -1,16 +1,18 @@
 class Solution {
   public int countSubstrings(String s) {
-    int N = s.length();
-    int ans = 0;
-    for (int center = 0; center <= 2 * N - 1; ++center) {
-        int left = center / 2;
-        int right = left + center % 2;
-        while (left >= 0 && right < N && s.charAt(left) == s.charAt(right)) {
-            ans++;
-            left--;
-            right++;
-        }
+    int[] palindromeCount = {0};
+    for (int i = 0; i < s.length(); i++) {
+      checkPalindrome(s, i, i, palindromeCount);
+      checkPalindrome(s, i, i + 1, palindromeCount);
+    }    
+    return palindromeCount[0];
+  }
+  
+  private void checkPalindrome(String s, int leftIdx, int rightIdx, int[] palindromeCount) {
+    while (leftIdx >= 0 && rightIdx < s.length() && s.charAt(leftIdx) == s.charAt(rightIdx)) {
+      palindromeCount[0]++;
+      leftIdx--;
+      rightIdx++;
     }
-    return ans;
   }
 }

From 5e36951e862856cfdeadd2a840a67a61d70657da Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Mar 2022 15:04:22 -0800
Subject: [PATCH 0855/2175] Update Find First and Last Position of Element in
 Sorted Array.java

---
 ...t Position of Element in Sorted Array.java | 47 ++++++++++++-------
 1 file changed, 29 insertions(+), 18 deletions(-)

diff --git a/Medium/Find First and Last Position of Element in Sorted Array.java b/Medium/Find First and Last Position of Element in Sorted Array.java
index 2d9e263a..89775bdf 100644
--- a/Medium/Find First and Last Position of Element in Sorted Array.java	
+++ b/Medium/Find First and Last Position of Element in Sorted Array.java	
@@ -1,28 +1,39 @@
 class Solution {
   public int[] searchRange(int[] nums, int target) {
-    return new int[]{binarySearchHelper(nums, target, -1), binarySearchHelper(nums, target, 1)};
-  } 
+    return new int[]{binarySearchForMinIdx(nums, target), binarySearchForMaxIdx(nums, target)};
+  }
   
-  private int binarySearchHelper(int[] nums, int target, int dir) {
-    int start = 0;
-    int end = nums.length - 1;
+  private int binarySearchForMinIdx(int[] nums, int target) {
+    int leftIdx = 0;
+    int rightIdx = nums.length - 1;
     int idx = -1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
+    while (leftIdx <= rightIdx) {
+      int mid = (leftIdx + rightIdx) / 2;
       if (nums[mid] == target) {
         idx = mid;
-        if (dir == -1) {
-          end = mid - 1;
-        }
-        else {
-          start = mid + 1;
-        }
-      }
-      else if (nums[mid] < target) {
-        start = mid + 1;
+        rightIdx = mid - 1;
+      } else if (nums[mid] > target) {
+        rightIdx = mid - 1;
+      } else {
+        leftIdx = mid + 1;
       }
-      else {
-        end = mid - 1;
+    }
+    return idx;
+  }
+  
+  private int binarySearchForMaxIdx(int[] nums, int target) {
+    int leftIdx = 0;
+    int rightIdx = nums.length - 1;
+    int idx = -1;
+    while (leftIdx <= rightIdx) {
+      int mid = (leftIdx + rightIdx) / 2;
+      if (nums[mid] == target) {
+        idx = mid;
+        leftIdx = mid + 1;
+      } else if (nums[mid] > target) {
+        rightIdx = mid - 1;
+      } else {
+        leftIdx = mid + 1;
       }
     }
     return idx;

From ae521b43b22afe32ae2f648c4a0bb71b826c07d8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Mar 2022 16:46:00 -0800
Subject: [PATCH 0856/2175] Update Kth Largest Element in an Array.java

---
 Medium/Kth Largest Element in an Array.java | 24 +++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/Medium/Kth Largest Element in an Array.java b/Medium/Kth Largest Element in an Array.java
index 1ba91b65..cc2f716c 100644
--- a/Medium/Kth Largest Element in an Array.java	
+++ b/Medium/Kth Largest Element in an Array.java	
@@ -1,12 +1,24 @@
 class Solution {
   public int findKthLargest(int[] nums, int k) {
-    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
-    for (int num : nums) {
-      priorityQueue.add(num);
-      if (priorityQueue.size() > k) {
-        priorityQueue.poll();
+    return quickSelect(nums, 0, nums.length - 1, nums.length - k);
+  }
+
+  private int quickSelect(int[] nums, int leftIdx, int rightIdx, int k) {
+    int pivot = nums[rightIdx];
+    int idx = leftIdx;
+    for (int i = leftIdx; i < rightIdx; i++) {
+      if (nums[i] <= pivot) {
+        swap(nums, i, idx);
+        idx++;
       }
     }
-    return priorityQueue.peek();
+    swap(nums, idx, rightIdx);
+    return idx == k ? nums[idx] : (idx > k ? quickSelect(nums, leftIdx, idx - 1, k) : quickSelect(nums, idx + 1, rightIdx, k));
+  }
+
+  private void swap(int[] nums, int idxOne, int idxTwo) {
+    int temp = nums[idxOne];
+    nums[idxOne] = nums[idxTwo];
+    nums[idxTwo] = temp;
   }
 }

From b2996e0e07450de6393966577bfbaeb76a4af563 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Mar 2022 08:37:33 -0800
Subject: [PATCH 0857/2175] Update Add Bold Tag in String.java

---
 Medium/Add Bold Tag in String.java | 58 ++++++++++++++++++------------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/Medium/Add Bold Tag in String.java b/Medium/Add Bold Tag in String.java
index bd262a02..024e1823 100644
--- a/Medium/Add Bold Tag in String.java	
+++ b/Medium/Add Bold Tag in String.java	
@@ -1,30 +1,44 @@
 class Solution {
-  public String addBoldTag(String S, String[] dict) {
-    int N = S.length();
-    boolean[] mask = new boolean[N];
-    for (int i = 0; i < N; ++i) {
-      for (String word: dict) search: {
-        for (int k = 0; k < word.length(); ++k) {
-          if (k + i >= S.length() || S.charAt(k + i) != word.charAt(k)) {
-            break search;
-          }
-        }
-        for (int j = i; j < i + word.length(); ++j) {
-          mask[j] = true;
-        }
+  public String addBoldTag(String s, String[] words) {
+    List<int[]> indexes = new ArrayList<>();
+    for (String word : words) {
+      indexes.addAll(getIndexPair(s, word));
+    }
+    Collections.sort(indexes,
+        Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1]));
+    Set<Integer> startIdx = new HashSet<>();
+    Set<Integer> endIdx = new HashSet<>();
+    int idx = 0;
+    while (idx < indexes.size()) {
+      int currStart = indexes.get(idx)[0];
+      int currEnd = indexes.get(idx)[1];
+      idx++;
+      while (idx < indexes.size() && indexes.get(idx)[0] <= currEnd + 1) {
+        currEnd = Math.max(currEnd, indexes.get(idx++)[1]);
       }
+      startIdx.add(currStart);
+      endIdx.add(currEnd);
     }
-    StringBuilder ans = new StringBuilder();
-    int anchor = 0;
-    for (int i = 0; i < N; ++i) {
-      if (mask[i] && (i == 0 || !mask[i - 1])) {
-        ans.append("<b>");
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < s.length(); i++) {
+      if (startIdx.contains(i)) {
+        sb.append("<b>");
+      }
+      sb.append(s.charAt(i));
+      if (endIdx.contains(i)) {
+        sb.append("</b>");
       }
-      ans.append(S.charAt(i));
-      if (mask[i] && (i == N - 1 || !mask[i + 1])) {
-        ans.append("</b>");
+    }
+    return sb.toString();
+  }
+
+  private List<int[]> getIndexPair(String s, String word) {
+    List<int[]> indexPairs = new ArrayList<>();
+    for (int i = 0; i < s.length() - word.length() + 1; i++) {
+      if (s.startsWith(word, i)) {
+        indexPairs.add(new int[]{i, i + word.length() - 1});
       }
     }
-    return ans.toString();
+    return indexPairs;
   }
 }

From 636a14218a085785aa39b50d878a0eaf850cca21 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Mar 2022 08:38:55 -0800
Subject: [PATCH 0858/2175] Update and rename Easy/Bold Words in String.java to
 Medium/Bold Words in String.java

---
 Easy/Bold Words in String.java   | 30 ----------------------
 Medium/Bold Words in String.java | 44 ++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 30 deletions(-)
 delete mode 100644 Easy/Bold Words in String.java
 create mode 100644 Medium/Bold Words in String.java

diff --git a/Easy/Bold Words in String.java b/Easy/Bold Words in String.java
deleted file mode 100644
index 16d3e6d3..00000000
--- a/Easy/Bold Words in String.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-class Solution {
-  public String boldWords(String[] words, String S) {
-    int N = S.length();
-    boolean[] mask = new boolean[N];
-    for (int i = 0; i < N; ++i) {
-      for (String word: words) search: {
-        for (int k = 0; k < word.length(); ++k) {
-          if (k + i >= S.length() || S.charAt(k + i) != word.charAt(k)) {
-            break search;
-          }
-        }
-        for (int j = i; j < i + word.length(); ++j) {
-          mask[j] = true;
-        }
-      }
-    }
-    StringBuilder ans = new StringBuilder();
-    int anchor = 0;
-    for (int i = 0; i < N; ++i) {
-      if (mask[i] && (i == 0 || !mask[i - 1])) {
-        ans.append("<b>");
-      }
-      ans.append(S.charAt(i));
-      if (mask[i] && (i == N - 1 || !mask[i + 1])) {
-        ans.append("</b>");
-      }
-    }
-    return ans.toString();
-  }
-}
diff --git a/Medium/Bold Words in String.java b/Medium/Bold Words in String.java
new file mode 100644
index 00000000..3e19c0a0
--- /dev/null
+++ b/Medium/Bold Words in String.java	
@@ -0,0 +1,44 @@
+class Solution {
+  public String boldWords(String[] words, String s) {
+    List<int[]> indexes = new ArrayList<>();
+    for (String word : words) {
+      indexes.addAll(getIndexPair(s, word));
+    }
+    Collections.sort(indexes,
+        Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1]));
+    Set<Integer> startIdx = new HashSet<>();
+    Set<Integer> endIdx = new HashSet<>();
+    int idx = 0;
+    while (idx < indexes.size()) {
+      int currStart = indexes.get(idx)[0];
+      int currEnd = indexes.get(idx)[1];
+      idx++;
+      while (idx < indexes.size() && indexes.get(idx)[0] <= currEnd + 1) {
+        currEnd = Math.max(currEnd, indexes.get(idx++)[1]);
+      }
+      startIdx.add(currStart);
+      endIdx.add(currEnd);
+    }
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < s.length(); i++) {
+      if (startIdx.contains(i)) {
+        sb.append("<b>");
+      }
+      sb.append(s.charAt(i));
+      if (endIdx.contains(i)) {
+        sb.append("</b>");
+      }
+    }
+    return sb.toString();
+  }
+  
+  private List<int[]> getIndexPair(String s, String word) {
+    List<int[]> indexPairs = new ArrayList<>();
+    for (int i = 0; i < s.length() - word.length() + 1; i++) {
+      if (s.startsWith(word, i)) {
+        indexPairs.add(new int[]{i, i + word.length() - 1});
+      }
+    }
+    return indexPairs;
+  }
+}

From ae32f305c409c9b33df8b8eb34c2139d03e97cd9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Mar 2022 17:36:06 -0800
Subject: [PATCH 0859/2175] Update Rotate List.java

---
 Medium/Rotate List.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Medium/Rotate List.java b/Medium/Rotate List.java
index a761b879..ddcbd094 100644
--- a/Medium/Rotate List.java	
+++ b/Medium/Rotate List.java	
@@ -13,17 +13,17 @@ public ListNode rotateRight(ListNode head, int k) {
     if (head == null || k == 0) {
       return head;
     }
-    int listSize = 0;
+    int n = 0;
     ListNode curr = head;
     while (curr != null) {
+      n++;
       curr = curr.next;
-      listSize++;
     }
-    k = k % listSize;
+    k = k % n;
     if (k == 0) {
       return head;
     }
-    k = listSize - k;
+    k = n - k;
     curr = head;
     while (k-- > 1) {
       curr = curr.next;

From aa1cbf8964eaca736b462b423a17a70125169014 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Mar 2022 08:48:24 -0800
Subject: [PATCH 0860/2175] Update Remove All Adjacent Duplicates in String
 II.java

---
 ... All Adjacent Duplicates in String II.java | 37 +++++++++----------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/Medium/Remove All Adjacent Duplicates in String II.java b/Medium/Remove All Adjacent Duplicates in String II.java
index f727a688..0cf6d3ac 100644
--- a/Medium/Remove All Adjacent Duplicates in String II.java	
+++ b/Medium/Remove All Adjacent Duplicates in String II.java	
@@ -1,36 +1,33 @@
 class Solution {
   public String removeDuplicates(String s, int k) {
-    Stack<Pair> stack = new Stack<>();
+    Stack<CharPair> stack = new Stack<>();
     for (char c : s.toCharArray()) {
-      if (!stack.isEmpty() && stack.peek().ch == c) {
-        stack.peek().val++;
+      if (!stack.isEmpty() && stack.peek().c == c) {
+        stack.peek().count++;
+      } else {
+        stack.push(new CharPair(c));
       }
-      else {
-        stack.push(new Pair(c, 1));
-      }
-      if (stack.peek().val == k) {
+      if (stack.peek().count == k) {
         stack.pop();
       }
     }
     StringBuilder sb = new StringBuilder();
     while (!stack.isEmpty()) {
-      Pair removed = stack.pop();
-      int count = removed.val;
-      while (count-- > 0) {
-        sb.append(removed.ch);
+      CharPair pair = stack.pop();
+      for (int i = 0; i < pair.count; i++) {
+        sb.append(pair.c);
       }
     }
     return sb.reverse().toString();
   }
-}
-
-
-class Pair {
-  char ch;
-  int val;
   
-  public Pair(char ch, int val) {
-    this.ch = ch;
-    this.val = val;
+  private static class CharPair {
+    char c;
+    int count;
+    
+    public CharPair(char c) {
+      this.c = c;
+      this.count = 1;
+    }
   }
 }

From 79cfcf6df942ce58bff969d3df97c289971c56f4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Mar 2022 12:44:14 -0800
Subject: [PATCH 0861/2175] Update Delete Nodes And Return Forest.java

---
 Medium/Delete Nodes And Return Forest.java | 55 ++++++++++------------
 1 file changed, 26 insertions(+), 29 deletions(-)

diff --git a/Medium/Delete Nodes And Return Forest.java b/Medium/Delete Nodes And Return Forest.java
index b65710bc..c3ec8f1b 100644
--- a/Medium/Delete Nodes And Return Forest.java	
+++ b/Medium/Delete Nodes And Return Forest.java	
@@ -4,46 +4,43 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
-    List<TreeNode> forest = new ArrayList<>();
-    Set<Integer> set = new HashSet<>();
-    for (int num : to_delete) {
-      set.add(num);
-    }
-    helper(root, set, forest, null, 0);
-    return forest;
+    List<TreeNode> result = new ArrayList<>();
+    Set<Integer> deleteSet = Arrays.stream(to_delete).boxed().collect(Collectors.toSet());
+    helper(root, deleteSet, result, null);
+    return result;
   }
   
-  private void helper(TreeNode root, Set<Integer> set, List<TreeNode> forest, TreeNode parent, int side) {
-    if (root == null) {
+  private void helper(TreeNode node, Set<Integer> deleteSet, List<TreeNode> result, TreeNode parent) {
+    if (node == null) {
       return;
     }
-    // Deletion 
-    if (set.contains(root.val)) {
-      if (parent != null) { 
-        // Decide which node we want to make null based on side
-        if (side == -1) {
+    TreeNode nextParent = null;
+    if (deleteSet.contains(node.val)) {
+      if (parent != null) {
+        if (parent.left == node) {
           parent.left = null;
-        }
-        else {
+        } else {
           parent.right = null;
         }
-      } 
-      // Call the recursive function for left & right with parent as null as we deleted the node
-      helper(root.left, set, forest, null, 0);
-      helper(root.right, set, forest, null, 0);
-    }
-    // No Deletion
-    else {
-      if (parent == null) { // Don't add if we have already added the parent and this is a child node
-        forest.add(root);
-      }  
-      helper(root.left, set, forest, root, -1);
-      helper(root.right, set, forest, root, 1);
+      }
+    } else {
+      if (parent == null) {
+        result.add(node); 
+      }
+      nextParent = node;
     }
+    helper(node.left, deleteSet, result, nextParent);
+    helper(node.right, deleteSet, result, nextParent);
   }
 }

From 4c36f760d050d6cf82ed5f090f0f22e5395f9eba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Mar 2022 13:06:57 -0800
Subject: [PATCH 0862/2175] Update Clone Binary Tree With Random Pointer.java

---
 ...Clone Binary Tree With Random Pointer.java | 61 +++++++++++--------
 1 file changed, 37 insertions(+), 24 deletions(-)

diff --git a/Medium/Clone Binary Tree With Random Pointer.java b/Medium/Clone Binary Tree With Random Pointer.java
index 922389ca..323b1b6e 100644
--- a/Medium/Clone Binary Tree With Random Pointer.java	
+++ b/Medium/Clone Binary Tree With Random Pointer.java	
@@ -1,5 +1,5 @@
 /**
- * Definition for a binary tree node.
+ * Definition for Node.
  * public class Node {
  *     int val;
  *     Node left;
@@ -15,33 +15,46 @@
  *     }
  * }
  */
+
 class Solution {
-  Map<Node, NodeCopy> copyMap;
   public NodeCopy copyRandomBinaryTree(Node root) {
-    copyMap = new HashMap<>();
-    fillMapTraverse(root);
-    cloneMapTraverse(root);
-    return copyMap.get(root);
-  }
-  
-  private void cloneMapTraverse(Node root) {
     if (root == null) {
-      return;
+      return null;
     }
-    NodeCopy copy = copyMap.get(root);
-    copy.left = copyMap.get(root.left);
-    copy.right = copyMap.get(root.right);
-    copy.random = copyMap.get(root.random);
-    cloneMapTraverse(root.left);
-    cloneMapTraverse(root.right);
-  }
-  
-  private void fillMapTraverse(Node root) {
-    if (root == null) {
-      return;
+    Queue<Node> queue = new LinkedList<>();
+    Map<Node, NodeCopy> map = new HashMap<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        Node removed = queue.remove();
+        map.put(removed, new NodeCopy(removed.val));
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+    }
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        Node removed = queue.remove();
+        if (removed.left != null) {
+          queue.add(removed.left);
+          map.get(removed).left = map.get(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+          map.get(removed).right = map.get(removed.right);
+        }
+        if (removed.random != null) {
+          map.get(removed).random = map.get(removed.random);
+        }
+      }
     }
-    copyMap.put(root, new NodeCopy(root.val));
-    fillMapTraverse(root.left);
-    fillMapTraverse(root.right);
+    return map.get(root);
   }
 }

From 25d2fb29a89e63c5dcca684ff21d6e41a39163e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Mar 2022 07:37:35 -0800
Subject: [PATCH 0863/2175] Update Monotonic Array.java

---
 Easy/Monotonic Array.java | 25 +++++++++----------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/Easy/Monotonic Array.java b/Easy/Monotonic Array.java
index b9a44bcb..c523cef1 100644
--- a/Easy/Monotonic Array.java	
+++ b/Easy/Monotonic Array.java	
@@ -1,25 +1,18 @@
 class Solution {
-  public boolean isMonotonic(int[] A) {
-    if (A.length <= 1) {
+  public boolean isMonotonic(int[] nums) {
+    if (nums.length < 2) {
       return true;
     }
-    int dir = 0;
-    int idx = 0;
-    while (idx < A.length - 1 && dir == 0) {
-      dir = getDir(A, idx);
-      idx++;
-    }
-    while (idx < A.length - 1) {
-      int tempDir = getDir(A, idx);
-      if (tempDir != 0 && tempDir != dir) {
+    Boolean increasing = null;
+    for (int i = 1; i < nums.length; i++) {
+      if (nums[i] == nums[i - 1] && increasing == null) {
+        continue;
+      }
+      increasing = increasing == null ? nums[i] > nums[i - 1] : increasing;
+      if ((nums[i] > nums[i - 1] && !increasing) || (nums[i] < nums[i - 1] && increasing)) {
         return false;
       }
-      idx++;
     }
     return true;
   }
-  
-  private int getDir(int[] A, int idx) {
-    return A[idx] < A[idx + 1] ? -1 : (A[idx] > A[idx + 1] ? 1 : 0);
-  }
 }

From 9ef91340180d8ad5616966143494dd8daecc5561 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Mar 2022 10:48:33 -0800
Subject: [PATCH 0864/2175] Update Find Leaves of Binary Tree.java

---
 Medium/Find Leaves of Binary Tree.java | 45 ++++++++++++++++++--------
 1 file changed, 32 insertions(+), 13 deletions(-)

diff --git a/Medium/Find Leaves of Binary Tree.java b/Medium/Find Leaves of Binary Tree.java
index 1bb713cd..c6449ce2 100644
--- a/Medium/Find Leaves of Binary Tree.java	
+++ b/Medium/Find Leaves of Binary Tree.java	
@@ -15,24 +15,43 @@
  */
 class Solution {
   public List<List<Integer>> findLeaves(TreeNode root) {
+    Map<TreeNode, TreeNode> parentMap = new HashMap<>();
+    Queue<TreeNode> leaves = new LinkedList<>();
+    updateParentAndFindLeaves(root, null, parentMap, leaves);
     List<List<Integer>> result = new ArrayList<>();
-    helper(result, root);
+    while (!leaves.isEmpty()) {
+      int size = leaves.size();
+      List<Integer> temp = new ArrayList<>();
+      while (size-- > 0) {
+        TreeNode removed = leaves.remove();
+        temp.add(removed.val);
+        if (parentMap.get(removed) == null) {
+          continue;
+        }
+        if (parentMap.get(removed).left == removed) {
+          parentMap.get(removed).left = null;
+        } else {
+          parentMap.get(removed).right = null;
+        }
+        if (parentMap.get(removed).left == null && parentMap.get(removed).right == null) {
+          leaves.add(parentMap.get(removed));
+        }
+      }
+      result.add(temp);
+    }
     return result;
   }
   
-  private int helper(List<List<Integer>> result, TreeNode root) {
-    if (root == null) {
-      return -1;
+  private void updateParentAndFindLeaves(TreeNode node, TreeNode parent, Map<TreeNode, TreeNode> parentMap, Queue<TreeNode> leaves) {
+    if (node == null) {
+      return;
     }
-    int left = helper(result, root.left);
-    int right = helper(result, root.right);
-    int maxDepth = Math.max(left, right) + 1;
-    if (maxDepth == result.size()) {
-      result.add(new ArrayList<>());
+    parentMap.put(node, parent);
+    if (node.left == null && node.right == null) {
+      leaves.add(node);
+      return;
     }
-    result.get(maxDepth).add(root.val);
-    // Cut the tree
-    root.left = root.right = null;
-    return maxDepth;
+    updateParentAndFindLeaves(node.left, node, parentMap, leaves);
+    updateParentAndFindLeaves(node.right, node, parentMap, leaves);
   }
 }

From 34bc252ff4178dc152806ebbaae425e59e445a62 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Mar 2022 16:05:06 -0800
Subject: [PATCH 0865/2175] Update Valid Parentheses.java

---
 Easy/Valid Parentheses.java | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/Easy/Valid Parentheses.java b/Easy/Valid Parentheses.java
index 3e93ca6e..911e52a5 100644
--- a/Easy/Valid Parentheses.java	
+++ b/Easy/Valid Parentheses.java	
@@ -1,15 +1,20 @@
 class Solution {
   public boolean isValid(String s) {
-    String starting = "({[";
-    String ending = ")}]";
     Stack<Character> stack = new Stack<>();
     for (char c : s.toCharArray()) {
-      if (starting.indexOf(c) != -1) {
+      if (c == '[' || c == '{' || c == '(') {
         stack.push(c);
       } else {
-        if (stack.isEmpty() || starting.indexOf(stack.pop()) != ending.indexOf(c)) {
+        if (stack.isEmpty()) {
           return false;
         }
+        char popped = stack.pop();
+        if ((c == ')' && popped == '(') || 
+            (c == ']' && popped == '[') ||
+            (c == '}' && popped == '{')) {
+          continue;
+        }
+        return false;
       }
     }
     return stack.isEmpty();

From cbc5225b144f6c4aaf197a51f8b6569c07a7a7ae Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Mar 2022 16:44:52 -0800
Subject: [PATCH 0866/2175] Update A Number After a Double Reversal.java

---
 Easy/A Number After a Double Reversal.java | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/Easy/A Number After a Double Reversal.java b/Easy/A Number After a Double Reversal.java
index 0175e45f..bace60bb 100644
--- a/Easy/A Number After a Double Reversal.java	
+++ b/Easy/A Number After a Double Reversal.java	
@@ -1,13 +1,11 @@
 class Solution {
   public boolean isSameAfterReversals(int num) {
-    return parseToInteger(reverseNum(parseToInteger(reverseNum(num)))) == num;
-  }
-  
-  private String reverseNum(int num) {
-    return new StringBuilder().append(num).reverse().toString();
-  }
-  
-  private Integer parseToInteger(String s) {
-    return Integer.parseInt(s);
+    if (num <= 9) {
+      return true;
+    }
+    if (num % 10 == 0) {
+      return false;
+    }
+    return true;
   }
 }

From 2ff8901ccacb7a13f2cd879b6c29f4ebb394d6f1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Mar 2022 18:53:37 -0800
Subject: [PATCH 0867/2175] Update and rename Easy/String Compression.java to
 Medium/String Compression.java

---
 Easy/String Compression.java   | 23 -----------------------
 Medium/String Compression.java | 22 ++++++++++++++++++++++
 2 files changed, 22 insertions(+), 23 deletions(-)
 delete mode 100644 Easy/String Compression.java
 create mode 100644 Medium/String Compression.java

diff --git a/Easy/String Compression.java b/Easy/String Compression.java
deleted file mode 100644
index 6b21d22e..00000000
--- a/Easy/String Compression.java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class Solution {
-  public int compress(char[] chars) {
-    int start = 0;
-    int end = 0;
-    int n = chars.length;
-    while (end < n) {
-      char c = chars[end];
-      int count = 0;
-      while (end < n && chars[end] == c) {
-        end++;
-        count++;
-      }
-      chars[start++] = c;
-      if (count > 1) {
-        String countStr = String.valueOf(count);
-        for (char countC : countStr.toCharArray()) {
-          chars[start++] = countC;
-        }
-      }
-    }
-    return start;
-  }
-}
diff --git a/Medium/String Compression.java b/Medium/String Compression.java
new file mode 100644
index 00000000..182df66f
--- /dev/null
+++ b/Medium/String Compression.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int compress(char[] chars) {
+    int idx = 0;
+    int startIdx = 0;
+    while (idx < chars.length) {
+      char c = chars[idx];
+      int count = 0;
+      while (idx < chars.length && chars[idx] == c) {
+        idx++;
+        count++;
+      }
+      chars[startIdx++] = c;
+      if (count > 1) {
+        String countString = String.valueOf(count);
+        for (char cs : countString.toCharArray()) {
+          chars[startIdx++] = cs;
+        }
+      }
+    }
+    return startIdx;
+  }
+}

From 8e0759dce6b7c400d3cf33f42e98fe5bd7606050 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Mar 2022 19:02:38 -0800
Subject: [PATCH 0868/2175] Update Longest Common Prefix.java

---
 Easy/Longest Common Prefix.java | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/Easy/Longest Common Prefix.java b/Easy/Longest Common Prefix.java
index 49a0dc92..fb655701 100644
--- a/Easy/Longest Common Prefix.java	
+++ b/Easy/Longest Common Prefix.java	
@@ -1,30 +1,22 @@
 class Solution {
   public String longestCommonPrefix(String[] strs) {
-    if (strs.length == 0) {
-      return "";
-    }
     int minLength = Integer.MAX_VALUE;
-    int idx = -1;
+    int minLengthIdx = -1;
     for (int i = 0; i < strs.length; i++) {
       if (strs[i].length() < minLength) {
         minLength = strs[i].length();
-        idx = i;
+        minLengthIdx = i;
       }
     }
     StringBuilder sb = new StringBuilder();
-    for (int i = 0; i < strs[idx].length(); i++) {
-      boolean flag = true;
+    for (int i = 0; i < strs[minLengthIdx].length(); i++) {
       for (String str : strs) {
-        if (str.charAt(i) != strs[idx].charAt(i)) {
-          flag = false;
-          break;
+        if (str.charAt(i) != strs[minLengthIdx].charAt(i)) {
+          return sb.toString();
         }
       }
-      if (!flag) {
-        break;
-      }
-      sb.append(strs[idx].charAt(i));
+      sb.append(strs[minLengthIdx].charAt(i));
     }
     return sb.toString();
-  }
+  }   
 }

From 72ce4fc48722dee18b77920ceb2342c782d76fb0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Mar 2022 08:44:22 -0700
Subject: [PATCH 0869/2175] Create Find All K-Distant Indices in an Array.java

---
 Easy/Find All K-Distant Indices in an Array.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Find All K-Distant Indices in an Array.java

diff --git a/Easy/Find All K-Distant Indices in an Array.java b/Easy/Find All K-Distant Indices in an Array.java
new file mode 100644
index 00000000..11fedb7d
--- /dev/null
+++ b/Easy/Find All K-Distant Indices in an Array.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public List<Integer> findKDistantIndices(int[] nums, int key, int k) {
+    List<Integer> result = new ArrayList<>();
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] == key) {
+        int start = Math.max(result.size() == 0 ? 0 : result.get(result.size() - 1) + 1, i - k);
+        for (int j = start; j <= i + k && j < nums.length; j++) {
+          result.add(j);
+        }
+      }
+    }
+    return result;
+  }
+}

From 4c1b04b01d843d344aaf9c58f0a33c7dfdf588bb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 14 Mar 2022 07:50:57 -0700
Subject: [PATCH 0870/2175] Create Maximize the Topmost Element After K
 Moves.java

---
 ...imize the Topmost Element After K Moves.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Maximize the Topmost Element After K Moves.java

diff --git a/Medium/Maximize the Topmost Element After K Moves.java b/Medium/Maximize the Topmost Element After K Moves.java
new file mode 100644
index 00000000..d8bb4948
--- /dev/null
+++ b/Medium/Maximize the Topmost Element After K Moves.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int maximumTop(int[] nums, int k) {
+    if (nums.length == 1) {
+      return k % 2 == 1 ? -1 : nums[0];
+    }
+    int maxTop = -1;
+    if (k < nums.length) {
+      maxTop = nums[k];
+    } else if (k > nums.length) {
+      k = nums.length + 1;
+    }
+    for (int i = 0; i < k - 1; i++) {
+      maxTop = Math.max(maxTop, nums[i]);
+    }
+    return maxTop;
+  }
+}

From 7bdd94a324d4f6dffe36f8035d79b53c1c9f07f2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Mar 2022 09:14:27 -0700
Subject: [PATCH 0871/2175] Update Second Minimum Node in a binary tree.java

---
 .../Second Minimum Node in a binary tree.java | 24 ++++++++-----------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/Easy/Second Minimum Node in a binary tree.java b/Easy/Second Minimum Node in a binary tree.java
index 2a3434b1..8ddeb335 100644
--- a/Easy/Second Minimum Node in a binary tree.java	
+++ b/Easy/Second Minimum Node in a binary tree.java	
@@ -13,26 +13,22 @@
  *     }
  * }
  */
-class Solution {  
-  Integer minimum;
-  long secondMinimum;
+class Solution {
   public int findSecondMinimumValue(TreeNode root) {
-    minimum = root.val;
-    secondMinimum = Long.MAX_VALUE;
-    helper(root);
-    return secondMinimum == Long.MAX_VALUE ? -1 : (int) secondMinimum;
+    long[] topTwo = {root.val, Long.MAX_VALUE};
+    helper(root, topTwo);
+    return topTwo[1] == Long.MAX_VALUE ? -1 : (int) topTwo[1];
   }
   
-  private void helper(TreeNode root) {
+  private void helper(TreeNode root, long[] topTwo) {
     if (root == null) {
       return;
     }
-    if (minimum < root.val && root.val < secondMinimum) {
-      secondMinimum = root.val;
-    }
-    else if (root.val == minimum) {
-      helper(root.left);
-      helper(root.right);
+    if (topTwo[0] < root.val && root.val < topTwo[1]) {
+      topTwo[1] = root.val;
+    } else {
+      helper(root.left, topTwo);
+      helper(root.right, topTwo);
     }
   }
 }

From 945d7160409fd3f0caf5564afc9ecf096b5789ed Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Mar 2022 11:57:46 -0700
Subject: [PATCH 0872/2175] Update All Nodes Distance K in Binary Tree.java

---
 .../All Nodes Distance K in Binary Tree.java  | 70 ++++++++-----------
 1 file changed, 29 insertions(+), 41 deletions(-)

diff --git a/Medium/All Nodes Distance K in Binary Tree.java b/Medium/All Nodes Distance K in Binary Tree.java
index 4c2ac67d..13e9485b 100644
--- a/Medium/All Nodes Distance K in Binary Tree.java	
+++ b/Medium/All Nodes Distance K in Binary Tree.java	
@@ -8,61 +8,49 @@
  * }
  */
 class Solution {
-  List<Integer> list;
-  TreeNode target;
-  int K;
-  public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
-    list = new ArrayList<>();
-    this.target = target;
-    this.K = K;
-    dfs(root);
-    return list;
+  public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
+    List<Integer> result = new ArrayList<>();
+    dfs(root, target, k, result);
+    return new ArrayList<>(result);
   }
-
-  private int dfs(TreeNode node) {
+  
+  private int dfs(TreeNode node, TreeNode target, int k, List<Integer> result) {
     if (node == null) {
       return -1;
     }
-    else if (node == target) {
-      subtreeDfs(node, 0);
+    if (node == target) {
+      addToResult(node, 0, result, k);
       return 1;
-    }
-    else {
-      int L = dfs(node.left);
-      int R = -1;
-      if (L != -1) {
-        if (L == K) {
-          list.add(node.val);
+    } else {
+      int left = dfs(node.left, target, k, result);
+      int right = dfs(node.right, target, k, result);
+      if (left != -1) {
+        if (left == k) {
+          result.add(node.val);
         }
-        subtreeDfs(node.right, L + 1);
-        return L + 1;
-      }
-      else if ((R = dfs(node.right)) != -1) {
-        if (R == K) {
-          list.add(node.val);
+        addToResult(node.right, left + 1, result, k);
+        return left + 1;
+      } else if (right != -1) {
+        if (right == k) {
+          result.add(node.val);
         }
-        subtreeDfs(node.left, R + 1);
-        return R + 1;
-      }
-      else {
+        addToResult(node.left, right + 1, result, k);
+        return right + 1;
+      } else {
         return -1;
       }
     }
   }
   
-  private void subtreeDfs(TreeNode node, int dist) {
-    if (node == null) {
-      return;
-    }
-    if (dist == K) {
-      list.add(node.val);
-    }
-    else if (dist > K) {
+  private void addToResult(TreeNode node, int dist, List<Integer> result, int k) {
+    if (node == null || dist > k) {
       return;
     }
-    else {
-      subtreeDfs(node.left, dist + 1);
-      subtreeDfs(node.right, dist + 1);
+    if (dist == k) {
+      result.add(node.val);
+    } else {
+      addToResult(node.left, dist + 1, result, k);
+      addToResult(node.right, dist + 1, result, k);
     }
   }
 }

From dd54248743848ef6f497c5f8e604ab983273fae0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Mar 2022 12:00:48 -0700
Subject: [PATCH 0873/2175] Update Implement strStr.java

---
 Easy/Implement strStr.java | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/Easy/Implement strStr.java b/Easy/Implement strStr.java
index bf12a2ed..ea05ba6f 100644
--- a/Easy/Implement strStr.java	
+++ b/Easy/Implement strStr.java	
@@ -1,14 +1,10 @@
 class Solution {
   public int strStr(String haystack, String needle) {
-    int hayLength = haystack.length();
-    int needleLength = needle.length();
-    int idx = 0;
-    while (idx + needleLength <= hayLength) {
-      if (haystack.substring(idx, idx + needleLength).equals(needle)) {
-        return idx;
+    for (int i = 0; i < haystack.length() - needle.length() + 1; i++) {
+      if (haystack.substring(i, i + needle.length()).equals(needle)) {
+        return i;
       }
-      idx++;
     }
     return -1;
-  }
+  } 
 }

From 610f29507cd5c92e3ce197917742c834ef1a3155 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Mar 2022 17:10:08 -0700
Subject: [PATCH 0874/2175] Update Validate Stack Sequences.java

---
 Medium/Validate Stack Sequences.java | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/Medium/Validate Stack Sequences.java b/Medium/Validate Stack Sequences.java
index a7535ce6..87d61d31 100644
--- a/Medium/Validate Stack Sequences.java	
+++ b/Medium/Validate Stack Sequences.java	
@@ -1,22 +1,21 @@
 class Solution {
   public boolean validateStackSequences(int[] pushed, int[] popped) {
     Stack<Integer> stack = new Stack<>();
-    int pushedIdx = 0;
-    int poppedIdx = 0;
-    while (pushedIdx < pushed.length && poppedIdx < popped.length) {
-      if (!stack.isEmpty() && stack.peek() == popped[poppedIdx]) {
+    int pushIdx = 0;
+    int popIdx = 0;
+    while (pushIdx < pushed.length) {
+      while (!stack.isEmpty() && popped[popIdx] == stack.peek()) {
         stack.pop();
-        poppedIdx++;
-      } else {
-        stack.push(pushed[pushedIdx++]);
+        popIdx++;
       }
+      stack.push(pushed[pushIdx++]);
     }
-    while (poppedIdx < popped.length) {
-      if (stack.peek() != popped[poppedIdx]) {
+    while (popIdx < popped.length) {
+      if (stack.isEmpty() || stack.peek() != popped[popIdx]) {
         return false;
       }
-      poppedIdx++;
       stack.pop();
+      popIdx++;
     }
     return true;
   }

From a39412cdb605f8aee9568aac09f88726e2a1696d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 16 Mar 2022 14:39:22 -0700
Subject: [PATCH 0875/2175] Update Flatten a Multilevel Doubly Linked List.java

---
 ...atten a Multilevel Doubly Linked List.java | 29 +++++++++----------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/Medium/Flatten a Multilevel Doubly Linked List.java b/Medium/Flatten a Multilevel Doubly Linked List.java
index 47dfdbb2..3708998f 100644
--- a/Medium/Flatten a Multilevel Doubly Linked List.java	
+++ b/Medium/Flatten a Multilevel Doubly Linked List.java	
@@ -11,27 +11,24 @@ class Node {
 class Solution {
   public Node flatten(Node head) {
     if (head == null) {
-      return null;
+      return head;
     }
     Stack<Node> stack = new Stack<>();
     stack.push(head);
-    Node dummy = new Node(0, null, head, null);
-    Node prev = dummy;
-    Node curr = dummy;
     while (!stack.isEmpty()) {
-      curr = stack.pop();
-      prev.next = curr;
-      curr.prev = prev;
-      if (curr.next != null) {
-        stack.push(curr.next);
+      Node removed = stack.pop();
+      if (removed.next != null) {
+        stack.push(removed.next);
       }
-      if (curr.child != null) {
-        stack.push(curr.child);
-        curr.child = null;
+      if (removed.child != null) {
+        stack.push(removed.child);
+      }
+      removed.child = null;
+      if (!stack.isEmpty()) {
+        removed.next = stack.peek();
+        stack.peek().prev = removed;
       }
-      prev = curr;
     }
-    dummy.next.prev = null;
-    return dummy.next;
-  }
+    return head;
+  } 
 }

From 319db72e1364e94bc1b7a4af8ac4eec756f8a3a5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 16 Mar 2022 14:44:05 -0700
Subject: [PATCH 0876/2175] Create Count Nodes Equal to Sum of Descendants.java

---
 ...unt Nodes Equal to Sum of Descendants.java | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Count Nodes Equal to Sum of Descendants.java

diff --git a/Medium/Count Nodes Equal to Sum of Descendants.java b/Medium/Count Nodes Equal to Sum of Descendants.java
new file mode 100644
index 00000000..85597629
--- /dev/null
+++ b/Medium/Count Nodes Equal to Sum of Descendants.java	
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int equalToDescendants(TreeNode root) {
+    int[] count = {0};
+    helper(root, count);
+    return count[0];
+  }
+  
+  private int helper(TreeNode root, int[] count) {
+    if (root == null) {
+      return 0;
+    }
+    int leftSum = helper(root.left, count);
+    int rightSum = helper(root.right, count);
+    if (root.val == leftSum + rightSum) {
+      count[0]++;
+    }
+    return root.val + leftSum + rightSum;
+  }
+}

From e5c33844f08652629bfadc4640cf5ccbeb3d94c3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 16 Mar 2022 15:27:02 -0700
Subject: [PATCH 0877/2175] Update Minimum Number of Steps to Make Two Strings
 Anagram.java

---
 ... of Steps to Make Two Strings Anagram.java | 23 ++++++++-----------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Medium/Minimum Number of Steps to Make Two Strings Anagram.java b/Medium/Minimum Number of Steps to Make Two Strings Anagram.java
index d81c4868..55139382 100644
--- a/Medium/Minimum Number of Steps to Make Two Strings Anagram.java	
+++ b/Medium/Minimum Number of Steps to Make Two Strings Anagram.java	
@@ -1,21 +1,16 @@
 class Solution {
   public int minSteps(String s, String t) {
-    int[] counterS = getFreqCounter(s);
-    int[] counterT = getFreqCounter(t);
-    int count = 0;
+    int[] frequency = new int[26];
+    for (int i = 0; i < s.length(); i++) {
+      frequency[s.charAt(i) - 'a']++;
+      frequency[t.charAt(i) - 'a']--;
+    }
+    int steps = 0;
     for (int i = 0; i < 26; i++) {
-      if (counterT[i] < counterS[i]) {
-        count += counterS[i] - counterT[i];
+      if (frequency[i] > 0) {
+        steps += frequency[i];
       }
     }
-    return count;
-  }
-  
-  private int[] getFreqCounter(String s) {
-    int[] counter = new int[26];
-    for (char c : s.toCharArray()) {
-      counter[c - 'a']++;
-    }
-    return counter;
+    return steps;
   }
 }

From c1556126f10a818a502c5896300487d3e8bd4963 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 19 Mar 2022 02:36:42 +0530
Subject: [PATCH 0878/2175] Update Remove Duplicate Letters.java

---
 Medium/Remove Duplicate Letters.java | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/Medium/Remove Duplicate Letters.java b/Medium/Remove Duplicate Letters.java
index 1f01908a..25cfd16c 100644
--- a/Medium/Remove Duplicate Letters.java	
+++ b/Medium/Remove Duplicate Letters.java	
@@ -1,27 +1,26 @@
 class Solution {
   public String removeDuplicateLetters(String s) {
     int[] counter = new int[26];
-    char[] charArray = s.toCharArray();
-    for (char c : charArray) {
+    for (char c : s.toCharArray()) {
       counter[c - 'a']++;
     }
+    Stack<Integer> stack = new Stack<>();
     boolean[] visited = new boolean[26];
-    Stack<Character> stack = new Stack<>();
-    for (Character c : charArray) {
+    for (char c : s.toCharArray()) {
       int idx = c - 'a';
       counter[idx]--;
       if (visited[idx]) {
         continue;
       }
-      while (!stack.isEmpty() && c < stack.peek() && counter[stack.peek() - 'a'] > 0) {
-        visited[stack.pop() - 'a'] = false;
+      while (!stack.isEmpty() && stack.peek() > idx && counter[stack.peek()] > 0) {
+        visited[stack.pop()] = false;
       }
-      stack.push(c);
+      stack.add(idx);
       visited[idx] = true;
     }
     StringBuilder sb = new StringBuilder();
     while (!stack.isEmpty()) {
-      sb.append(stack.pop());
+      sb.append((char) (stack.pop() + 'a'));
     }
     return sb.reverse().toString();
   }

From 57ba3d5cce2924500905dec37d7333b06dc6348d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 19 Mar 2022 08:55:23 +0530
Subject: [PATCH 0879/2175] Create Find Distance in a Binary Tree.java

---
 Medium/Find Distance in a Binary Tree.java | 51 ++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 Medium/Find Distance in a Binary Tree.java

diff --git a/Medium/Find Distance in a Binary Tree.java b/Medium/Find Distance in a Binary Tree.java
new file mode 100644
index 00000000..403e1190
--- /dev/null
+++ b/Medium/Find Distance in a Binary Tree.java	
@@ -0,0 +1,51 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int findDistance(TreeNode root, int p, int q) {
+    if (p == q) {
+      return 0;
+    }
+    int[] result = {-1};
+    dfs(root, p, q, result);
+    return result[0];
+  }
+  
+  private int dfs(TreeNode root, int p, int q, int[] result) {
+    if (root == null) {
+      return -1;
+    }
+    int left = dfs(root.left, p, q, result);
+    int right = dfs(root.right, p, q, result);
+    if (root.val == p || root.val == q) {
+      if (left < 0 && right < 0) {
+        return 0;
+      }
+      result[0] = 1 + (left >= 0 ? left : right);
+      return -1;
+    }
+    if (left >= 0 && right >= 0) {
+      result[0] = left + right + 2;
+      return -1;
+    }
+    if (left >= 0) {
+      return left + 1;
+    }
+    if (right >= 0) {
+      return right + 1;
+    }
+    return -1;
+  }
+}

From 9ac0691145332abe4d16d94bf2cc97e93a1eeb83 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 19 Mar 2022 23:41:17 +0530
Subject: [PATCH 0880/2175] Update Maximum Frequency Stack.java

---
 Hard/Maximum Frequency Stack.java | 33 +++++++++++++++++--------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/Hard/Maximum Frequency Stack.java b/Hard/Maximum Frequency Stack.java
index 9acd4a53..a638cede 100644
--- a/Hard/Maximum Frequency Stack.java	
+++ b/Hard/Maximum Frequency Stack.java	
@@ -1,24 +1,27 @@
 class FreqStack {
-  Map<Integer, Integer> valueToCurrentFrequency;
-  Map<Integer, Stack<Integer>> frequencyToValues;
-  int maxFrequency;
+  
+  private Map<Integer, Integer> frequencyMap;
+  private Map<Integer, Stack<Integer>> frequencyGroup;
+  private int maxFrequency;
+  
   public FreqStack() {
-    valueToCurrentFrequency = new HashMap<>();
-    frequencyToValues = new HashMap<>();
-    maxFrequency = 1;
+    this.frequencyMap = new HashMap<>();
+    this.frequencyGroup = new HashMap<>();
+    this.maxFrequency = 0;
   }
 
-  public void push(int x) {
-    valueToCurrentFrequency.put(x, valueToCurrentFrequency.getOrDefault(x, 0) + 1);
-    frequencyToValues.computeIfAbsent(valueToCurrentFrequency.get(x), k -> new Stack<>()).add(x);
-    maxFrequency = Math.max(maxFrequency, valueToCurrentFrequency.get(x));
+  public void push(int val) {
+    int newFrequency = this.frequencyMap.getOrDefault(val, 0) + 1;
+    this.frequencyMap.put(val, newFrequency);
+    this.maxFrequency = Math.max(this.maxFrequency, newFrequency);
+    this.frequencyGroup.computeIfAbsent(newFrequency, k -> new Stack<>()).push(val);
   }
 
   public int pop() {
-    int val = frequencyToValues.get(maxFrequency).pop();
-    valueToCurrentFrequency.put(val, valueToCurrentFrequency.getOrDefault(val, 0) - 1);
-    if (frequencyToValues.get(maxFrequency).isEmpty()) {
-      maxFrequency--;
+    int val = this.frequencyGroup.get(this.maxFrequency).pop();
+    this.frequencyMap.put(val, this.frequencyMap.get(val) - 1);
+    if (this.frequencyGroup.get(this.maxFrequency).isEmpty()) {
+      this.maxFrequency--;
     }
     return val;
   }
@@ -27,6 +30,6 @@ public int pop() {
 /**
  * Your FreqStack object will be instantiated and called as such:
  * FreqStack obj = new FreqStack();
- * obj.push(x);
+ * obj.push(val);
  * int param_2 = obj.pop();
  */

From f9c4b98c45e5d6ebb2c6f307c0779eac97699dd5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Mar 2022 03:59:52 +0530
Subject: [PATCH 0881/2175] Create Divide Array Into Equal Pairs.java

---
 Easy/Divide Array Into Equal Pairs.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Divide Array Into Equal Pairs.java

diff --git a/Easy/Divide Array Into Equal Pairs.java b/Easy/Divide Array Into Equal Pairs.java
new file mode 100644
index 00000000..ce8122d3
--- /dev/null
+++ b/Easy/Divide Array Into Equal Pairs.java	
@@ -0,0 +1,8 @@
+class Solution {
+  public boolean divideArray(int[] nums) {
+    return Arrays.stream(nums)
+        .boxed()
+        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()))
+        .values().stream().allMatch(e -> e % 2 == 0);
+  }
+}

From c1edc227c3b5b76ea7f9c0f4dbd910b5d8e0f666 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Mar 2022 07:23:09 +0530
Subject: [PATCH 0882/2175] Create Maximize Number of Subsequences in a
 String.java

---
 ...mize Number of Subsequences in a String.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Maximize Number of Subsequences in a String.java

diff --git a/Medium/Maximize Number of Subsequences in a String.java b/Medium/Maximize Number of Subsequences in a String.java
new file mode 100644
index 00000000..c2c26208
--- /dev/null
+++ b/Medium/Maximize Number of Subsequences in a String.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public long maximumSubsequenceCount(String text, String pattern) {
+    long result = 0;
+    int countCharOne = 0;
+    int countCharTwo = 0;
+    for (char c : text.toCharArray()) {
+      if (c == pattern.charAt(1)) {
+        result += countCharOne;
+        countCharTwo++;
+      }
+      if (c == pattern.charAt(0)) {
+        countCharOne++;
+      }
+    }
+    return result + Math.max(countCharOne, countCharTwo);
+  }
+}

From 06bb8bc812c524904b5c0c459a5b86e4527dbf65 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Mar 2022 05:31:29 +0530
Subject: [PATCH 0883/2175] Create Count Hills and Valleys in an Array.java

---
 Easy/Count Hills and Valleys in an Array.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Count Hills and Valleys in an Array.java

diff --git a/Easy/Count Hills and Valleys in an Array.java b/Easy/Count Hills and Valleys in an Array.java
new file mode 100644
index 00000000..750cc964
--- /dev/null
+++ b/Easy/Count Hills and Valleys in an Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int countHillValley(int[] nums) {
+    List<Integer> list = new ArrayList<>();
+    list.add(nums[0]);
+    for (int i = 1; i < nums.length; i++) {
+      if (nums[i] != nums[i - 1]) {
+        list.add(nums[i]);
+      }
+    }
+    int hillsAndVallies = 0;
+    for (int i = 1; i < list.size() - 1; i++) {
+      if ((list.get(i) < list.get(i - 1) && list.get(i) < list.get(i + 1)) || 
+          (list.get(i) > list.get(i - 1) && list.get(i) > list.get(i + 1))) {
+        hillsAndVallies++;
+      }
+    }
+    return hillsAndVallies;
+  }
+}

From cd3c7b9ea579c69ea2fa392e937ecf61cb01c038 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Mar 2022 06:32:01 +0530
Subject: [PATCH 0884/2175] Create Count Collisions on a Road.java

---
 Medium/Count Collisions on a Road.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Count Collisions on a Road.java

diff --git a/Medium/Count Collisions on a Road.java b/Medium/Count Collisions on a Road.java
new file mode 100644
index 00000000..aa3d6358
--- /dev/null
+++ b/Medium/Count Collisions on a Road.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int countCollisions(String directions) {
+    int idx = 0;
+    while (idx < directions.length() && directions.charAt(idx) == 'L') {
+      idx++;
+    }
+    int carsFromRight = 0;
+    int collisionCount = 0;
+    while (idx < directions.length()) {
+      if (directions.charAt(idx) == 'R') {
+        carsFromRight++;
+      } else {
+        collisionCount += directions.charAt(idx) == 'S' ? carsFromRight : carsFromRight + 1;
+        carsFromRight = 0;
+      }
+      idx++;
+    }
+    return collisionCount;
+  }
+}

From 9e1c92a3d38302235091cd5afd94c682846d94ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Mar 2022 08:22:48 +0530
Subject: [PATCH 0885/2175] Update Partition Labels.java

---
 Medium/Partition Labels.java | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/Medium/Partition Labels.java b/Medium/Partition Labels.java
index c407b224..d8896c4a 100644
--- a/Medium/Partition Labels.java	
+++ b/Medium/Partition Labels.java	
@@ -1,22 +1,19 @@
 class Solution {
-  public List<Integer> partitionLabels(String S) {
-    if (S == null || S.length() == 0) {
-      return new ArrayList<>();
+  public List<Integer> partitionLabels(String s) {
+    Map<Character, Integer> lastIndex = new HashMap<>();
+    for (int i = 0; i < s.length(); i++) {
+      lastIndex.put(s.charAt(i), i);
     }
-    int[] count = new int[26];
-    for (int i = 0; i < S.length(); i++) {
-      count[S.charAt(i) - 'a'] = i;
-    }
-    int start = -1;
-    int end = 0;
-    List<Integer> list = new ArrayList<>();
-    for (int i = 0; i < S.length(); i++) {
-      end = Math.max(end, count[S.charAt(i) - 'a']);
-      if (end == i) {
-        list.add(end - start);
-        start = end;
+    List<Integer> partitionIndices = new ArrayList<>();
+    int currMaxIdx = -1;
+    int prevIdx = 0;
+    for (int i = 0; i < s.length(); i++) {
+      currMaxIdx = Math.max(currMaxIdx, lastIndex.get(s.charAt(i)));
+      if (i == currMaxIdx) {
+        partitionIndices.add(i - prevIdx + 1);
+        prevIdx = i + 1;
       }
     }
-    return list;
+    return partitionIndices;
   }
 }

From 2ab955507b4703cf7a2f3e34cde3b99658dbc0b1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Mar 2022 21:03:57 +0530
Subject: [PATCH 0886/2175] Update Reconstruct Original Digits from
 English.java

---
 ...onstruct Original Digits from English.java | 55 +++++++++----------
 1 file changed, 27 insertions(+), 28 deletions(-)

diff --git a/Medium/Reconstruct Original Digits from English.java b/Medium/Reconstruct Original Digits from English.java
index 77f44e20..606452a6 100644
--- a/Medium/Reconstruct Original Digits from English.java	
+++ b/Medium/Reconstruct Original Digits from English.java	
@@ -1,31 +1,30 @@
 class Solution {
-    public String originalDigits(String s) {
-        int[] count = new int[26];
-        for (char c : s.toCharArray()) {
-            count[c - 'a']++;
-        }
-        
-        int[] out = new int[10];
-        
-        out[0] = count['z' - 'a'];
-        out[2] = count['w' - 'a'];
-        out[4] = count['u' - 'a'];
-        out[6] = count['x' - 'a'];
-        out[8] = count['g' - 'a'];
-        out[3] = count['h' - 'a'] - out[8];
-        out[5] = count['f' - 'a'] - out[4];
-        out[7] = count['s' - 'a'] - out[6];
-        out[9] = count['i' - 'a'] - out[5] - out[6] - out[8];
-        out[1] = count['n' - 'a'] - out[7] - 2 * out[9];
-        
-        StringBuilder sb = new StringBuilder();
-        
-        for (int i = 0; i < 10; i++) {
-            for (int j = 0; j < out[i]; j++) {
-                sb.append(i);        
-            }
-        }
-        
-        return sb.toString();
+  public String originalDigits(String s) {
+    int[] count = new int[10];
+    for (int i = 0; i < s.length(); i++){
+      char c = s.charAt(i);
+      if (c == 'z') count[0]++;
+      if (c == 'w') count[2]++;
+      if (c == 'x') count[6]++;
+      if (c == 's') count[7]++; //7-6
+      if (c == 'g') count[8]++;
+      if (c == 'u') count[4]++; 
+      if (c == 'f') count[5]++; //5-4
+      if (c == 'h') count[3]++; //3-8
+      if (c == 'i') count[9]++; //9-8-5-6
+      if (c == 'o') count[1]++; //1-0-2-4
     }
+    count[7] -= count[6];
+    count[5] -= count[4];
+    count[3] -= count[8];
+    count[9] = count[9] - count[8] - count[5] - count[6];
+    count[1] = count[1] - count[0] - count[2] - count[4];
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i <= 9; i++){
+      for (int j = 0; j < count[i]; j++){
+          sb.append(i);
+      }
+    }
+    return sb.toString();
+  }
 }

From 67036e7edd268a51587ed3e6fa7eb9afcf533442 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Mar 2022 00:58:58 +0530
Subject: [PATCH 0887/2175] Update Design Underground System.java

---
 Medium/Design Underground System.java | 33 +++++++++++++++------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/Medium/Design Underground System.java b/Medium/Design Underground System.java
index 730aaa49..51aa492a 100644
--- a/Medium/Design Underground System.java	
+++ b/Medium/Design Underground System.java	
@@ -1,30 +1,33 @@
 class UndergroundSystem {
-  Map<Integer, String> checkInMap;
-  Map<String, Integer> timeMap;
-  Map<String, Integer> countMap;
+  
+  private Map<String, Integer> totalTimeFromStartToEndStation;
+  private Map<String, Integer> numberOfCustomersFromStartToEndStation;
+  private Map<Integer, Integer> customerIdToStartTime;
+  private Map<Integer, String> customerIdToStartStation;
+  
   public UndergroundSystem() {
-    checkInMap = new HashMap<>();
-    timeMap = new HashMap<>();
-    countMap = new HashMap<>();
+    this.totalTimeFromStartToEndStation = new HashMap<>();
+    this.numberOfCustomersFromStartToEndStation = new HashMap<>();
+    this.customerIdToStartTime = new HashMap<>();
+    this.customerIdToStartStation = new HashMap<>();
   }
 
   public void checkIn(int id, String stationName, int t) {
-    checkInMap.put(id, stationName + "," + t);
+    this.customerIdToStartTime.put(id, t);
+    this.customerIdToStartStation.put(id, stationName);
   }
 
   public void checkOut(int id, String stationName, int t) {
-    String val = checkInMap.get(id);
-    String prevStationName = val.split(",")[0];
-    int prevTime = Integer.parseInt(val.split(",")[1]);
-    String key = prevStationName + "|" + stationName;
-    timeMap.put(key, timeMap.getOrDefault(key, 0) + t - prevTime);
-    countMap.put(key, countMap.getOrDefault(key, 0) + 1);
+    int totalTime = t - this.customerIdToStartTime.get(id);
+    String key = this.customerIdToStartStation.get(id) + "|" + stationName;
+    this.totalTimeFromStartToEndStation.put(key, this.totalTimeFromStartToEndStation.getOrDefault(key, 0) + totalTime);
+    this.numberOfCustomersFromStartToEndStation.put(key, this.numberOfCustomersFromStartToEndStation.getOrDefault(key, 0) + 1);
   }
 
   public double getAverageTime(String startStation, String endStation) {
     String key = startStation + "|" + endStation;
-    return ((double) timeMap.get(key)) / countMap.get(key);
-  }
+    return this.totalTimeFromStartToEndStation.get(key) / (double) (this.numberOfCustomersFromStartToEndStation.get(key));
+   }
 }
 
 /**

From 38c9b25378168ed996f9ef91951b17a53f10b9d5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Mar 2022 08:36:33 +0530
Subject: [PATCH 0888/2175] Update Smallest String With A Given Numeric
 Value.java

---
 .../Smallest String With A Given Numeric Value.java | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/Medium/Smallest String With A Given Numeric Value.java b/Medium/Smallest String With A Given Numeric Value.java
index 929b7ade..6957c53c 100644
--- a/Medium/Smallest String With A Given Numeric Value.java	
+++ b/Medium/Smallest String With A Given Numeric Value.java	
@@ -1,14 +1,11 @@
 class Solution {
   public String getSmallestString(int n, int k) {
     StringBuilder sb = new StringBuilder();
-    for (int idx = 0; idx < n; idx++) {
-      for (int currChar = 26; currChar > 0; currChar--) {
-        if (currChar <= k && k - currChar >= (n - idx - 1)) {
-          sb.append((char) (97 + currChar - 1));
-          k -= currChar;
-          break;
-        }
-      }
+    while (k > 0) {
+      int maxPossible = Math.min(k - n + 1, 26);
+      sb.append((char) ('a' + maxPossible - 1));
+      k -= maxPossible;
+      n--;
     }
     return sb.reverse().toString();
   }

From 1eff3fb6784df14552daaae83ff201206f14896c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Mar 2022 09:01:36 +0530
Subject: [PATCH 0889/2175] Update and rename Hard/Longest Substring with At
 Most K Distinct Characters.java to Medium/Longest Substring with At Most K
 Distinct Characters.java

---
 ...ng with At Most K Distinct Characters.java | 22 -------------------
 ...ng with At Most K Distinct Characters.java | 21 ++++++++++++++++++
 2 files changed, 21 insertions(+), 22 deletions(-)
 delete mode 100644 Hard/Longest Substring with At Most K Distinct Characters.java
 create mode 100644 Medium/Longest Substring with At Most K Distinct Characters.java

diff --git a/Hard/Longest Substring with At Most K Distinct Characters.java b/Hard/Longest Substring with At Most K Distinct Characters.java
deleted file mode 100644
index ae6a1c78..00000000
--- a/Hard/Longest Substring with At Most K Distinct Characters.java	
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-  public int lengthOfLongestSubstringKDistinct(String s, int k) {
-    Map<Character, Integer> map = new HashMap<>();
-    int slow = 0;
-    int fast = 0;
-    int n = s.length();
-    int maxLength = 0;
-    while (fast < n) {
-      map.put(s.charAt(fast), map.getOrDefault(s.charAt(fast), 0) + 1);
-      while (map.size() > k) {
-        map.put(s.charAt(slow), map.getOrDefault(s.charAt(slow), 0) - 1);
-        if (map.get(s.charAt(slow)) == 0) {
-          map.remove(s.charAt(slow));
-        }
-        slow++;
-      }
-      fast++;
-      maxLength = Math.max(maxLength, fast - slow);
-    }
-    return maxLength;
-  }
-}
diff --git a/Medium/Longest Substring with At Most K Distinct Characters.java b/Medium/Longest Substring with At Most K Distinct Characters.java
new file mode 100644
index 00000000..02936a53
--- /dev/null
+++ b/Medium/Longest Substring with At Most K Distinct Characters.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int lengthOfLongestSubstringKDistinct(String s, int k) {
+    Map<Character, Integer> map = new HashMap<>();
+    int startIdx = 0;
+    int endIdx = 0;
+    int maxLength = 0;
+    while (endIdx < s.length()) {
+      map.put(s.charAt(endIdx), map.getOrDefault(s.charAt(endIdx), 0) + 1);
+      endIdx++;
+      while (startIdx < endIdx && map.size() > k) {
+        map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0 ) - 1);
+        if (map.get(s.charAt(startIdx))  == 0) {
+          map.remove(s.charAt(startIdx));
+        }
+        startIdx++;
+      }
+      maxLength = Math.max(maxLength, endIdx - startIdx);
+    }
+    return maxLength;
+  }
+}

From f5ee3f0bc7352864af3b29c6ef61059b5ef93246 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 23 Mar 2022 02:01:38 +0530
Subject: [PATCH 0890/2175] Update Reorder Data in Log Files.java

---
 Easy/Reorder Data in Log Files.java | 34 ++++++++++-------------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/Easy/Reorder Data in Log Files.java b/Easy/Reorder Data in Log Files.java
index df293c3d..86d8786d 100644
--- a/Easy/Reorder Data in Log Files.java	
+++ b/Easy/Reorder Data in Log Files.java	
@@ -3,33 +3,23 @@ public String[] reorderLogFiles(String[] logs) {
     List<String> letterLogs = new ArrayList<>();
     List<String> digitLogs = new ArrayList<>();
     for (String log : logs) {
-      String[] strs = log.split("\\s+");
-      if (Character.isDigit(strs[1].charAt(0))) {
+      String[] split = log.split("\\s+");
+      if (Character.isDigit(split[1].charAt(0))) {
         digitLogs.add(log);
-      }
-      else {
+      } else {
         letterLogs.add(log);
       }
     }
-    Collections.sort(letterLogs, new Comparator<String>(){
-      public int compare(String s1, String s2) {
-        String key1 = s1.substring(s1.indexOf(' ') + 1);
-        String key2 = s2.substring(s2.indexOf(' ') + 1);
-        int c = key1.compareTo(key2);
-        if (c != 0) {
-          return c;
-        }
-        return s1.substring(0, s1.indexOf(' ')).compareTo(s2.substring(0, s2.indexOf(' ')));
+    letterLogs.sort((o1, o2) -> {
+      String contentOne = o1.substring(o1.indexOf(" ") + 1);
+      String contentTwo = o2.substring(o2.indexOf(" ") + 1);
+      int c = contentOne.compareTo(contentTwo);
+      if (c != 0) {
+        return c;
       }
+      return o1.substring(0, o1.indexOf(" ")).compareTo(o2.substring(0, o2.indexOf(" ")));
     });
-    String[] ans = new String[logs.length];
-    int idx = 0;
-    for (String log : letterLogs) {
-      ans[idx++] = log;
-    }
-    for (String log : digitLogs) {
-      ans[idx++] = log;
-    }
-    return ans;
+    letterLogs.addAll(digitLogs);
+    return letterLogs.toArray(new String[0]);
   }
 }

From 748c34d88d92c0978aff251814ad28eee1bc5ef6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 23 Mar 2022 22:58:30 +0530
Subject: [PATCH 0891/2175] Update Broken Calculator.java

---
 Medium/Broken Calculator.java | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/Medium/Broken Calculator.java b/Medium/Broken Calculator.java
index a746211a..ea40c3e7 100644
--- a/Medium/Broken Calculator.java	
+++ b/Medium/Broken Calculator.java	
@@ -1,10 +1,14 @@
 class Solution {
-  public int brokenCalc(int X, int Y) {
-    int count = 0;
-    while (Y > X) {
-      count++;
-      Y = Y % 2 == 1 ? Y + 1 : Y / 2;
+  public int brokenCalc(int startValue, int target) {
+    int numOfSteps = 0;
+    while (target > startValue) {
+      numOfSteps++;
+      if (target % 2 == 1) {
+        target++;
+      } else {
+        target /= 2;
+      }
     }
-    return count + X - Y;
+    return numOfSteps + startValue - target;
   }
 }

From becfa84e64ec368dc94e9a183d748ac4f1207f6b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 24 Mar 2022 01:35:28 +0530
Subject: [PATCH 0892/2175] Create Implement Trie II (Prefix Tree).java

---
 Medium/Implement Trie II (Prefix Tree).java | 89 +++++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 Medium/Implement Trie II (Prefix Tree).java

diff --git a/Medium/Implement Trie II (Prefix Tree).java b/Medium/Implement Trie II (Prefix Tree).java
new file mode 100644
index 00000000..e6bae27d
--- /dev/null
+++ b/Medium/Implement Trie II (Prefix Tree).java	
@@ -0,0 +1,89 @@
+class Trie {
+
+  private Node head;
+
+  public Trie() {
+    this.head = new Node('-');
+  }
+
+  public void insert(String word) {
+    Node curr = this.head;
+    for (char c : word.toCharArray()) {
+      if (!curr.children.containsKey(c)) {
+        curr.children.put(c, new Node(c));
+      }
+      curr = curr.children.get(c);
+    }
+    curr.wordToFrequency.put(word, curr.wordToFrequency.getOrDefault(word, 0) + 1);
+  }
+
+  public int countWordsEqualTo(String word) {
+    Node curr = this.head;
+    curr = traverseTrie(curr, word);
+    if (curr == null) {
+      return 0;
+    }
+    return curr.wordToFrequency.getOrDefault(word, 0);
+  }
+
+  public int countWordsStartingWith(String prefix) {
+    Node curr = this.head;
+    curr = traverseTrie(curr, prefix);
+    if (curr == null) {
+      return 0;
+    }
+    int count = 0;
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(curr);
+    while (!queue.isEmpty()) {
+      Node removed = queue.remove();
+      for (String word : removed.wordToFrequency.keySet()) {
+        count += removed.wordToFrequency.get(word);
+      }
+      for (Character child : removed.children.keySet()) {
+        queue.add(removed.children.get(child));
+      }
+    }
+    return count;
+  }
+
+  public void erase(String word) {
+    Node curr = this.head;
+    curr = traverseTrie(curr, word);
+    if (curr == null || curr.wordToFrequency.getOrDefault(word, 0) == 0) {
+      return;
+    }
+    curr.wordToFrequency.put(word, curr.wordToFrequency.get(word) - 1);
+  }
+
+  private Node traverseTrie(Node curr, String word) {
+    for (char c : word.toCharArray()) {
+      if (!curr.children.containsKey(c)) {
+        return null;
+      }
+      curr = curr.children.get(c);
+    }
+    return curr;
+  }
+
+  private static class Node {
+    char c;
+    Map<Character, Node> children;
+    Map<String, Integer> wordToFrequency;
+
+    public Node(char c) {
+      this.c = c;
+      this.children = new HashMap<>();
+      this.wordToFrequency = new HashMap<>();
+    }
+  }
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * int param_2 = obj.countWordsEqualTo(word);
+ * int param_3 = obj.countWordsStartingWith(prefix);
+ * obj.erase(word);
+ */

From fac10d2b0f873ce16f03911d9717ae95978a8671 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 25 Mar 2022 04:36:31 +0530
Subject: [PATCH 0893/2175] Update Expressive Words.java

---
 Medium/Expressive Words.java | 73 ++++++++++++++----------------------
 1 file changed, 29 insertions(+), 44 deletions(-)

diff --git a/Medium/Expressive Words.java b/Medium/Expressive Words.java
index b9b70e1e..2903acba 100644
--- a/Medium/Expressive Words.java	
+++ b/Medium/Expressive Words.java	
@@ -1,47 +1,32 @@
 class Solution {
-    public int expressiveWords(String S, String[] words) {
-        int count = 0;    
-        char[] sChar = S.toCharArray();
-        for (String word : words) {
-            char[] wChar = word.toCharArray();
-            if (check(sChar, wChar)) {
-                count++;
-            }
-        }
-        
-        return count;
-    }
-    
-    private boolean check(char[] s, char[] w) {
-        int i = 0;
-        int j = 0;
-        
-        while (i < s.length && j < w.length) {
-            if (s[i] != w[j]) {
-                return false;
-            }
-            
-            int tempI = i;
-            int tempJ = j;
-            
-            while (i < s.length && s[i] == s[tempI]) {
-                i++;
-            }
-            
-            while (j < w.length && w[j] == w[tempJ]) {
-                j++;
-            }
-            
-            int l1 = i - tempI;
-            int l2 = j - tempJ;
-            
-            if (l1 == l2 || l1 >= 3 && l1 > l2) {
-                continue;
-            }
-            
-            return false;
-        }
-        
-        return i == s.length && j == w.length;
+  public int expressiveWords(String s, String[] words) {
+    return (int) Arrays.stream(words).filter(word -> isExpressive(s, word)).count();
+  }
+  
+  private boolean isExpressive(String s, String word) {
+    int sIdx = 0;
+    int wordIdx = 0;
+    while (sIdx < s.length() && wordIdx < word.length()) {
+      if (s.charAt(sIdx) != word.charAt(wordIdx)) {
+        return false;
+      }
+      char c1 = s.charAt(sIdx);
+      int countC1 = 0;
+      while (sIdx < s.length() && s.charAt(sIdx) == c1) {
+        sIdx++;
+        countC1++;
+      }
+      char c2 = word.charAt(wordIdx);
+      int countC2 = 0;
+      while (wordIdx < word.length() && word.charAt(wordIdx) == c2) {
+        wordIdx++;
+        countC2++;
+      }
+      if (countC1 == countC2 || (countC1 > countC2 && countC1 >= 3)) {
+        continue;
+      }
+      return false;
     }
+    return sIdx == s.length() && wordIdx == word.length();
+  }
 }

From 916cbdb1a53d4e7f3b938d9786f2a1a4351729e6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 25 Mar 2022 10:57:31 +0530
Subject: [PATCH 0894/2175] Update Count Binary Substrings.java

---
 Easy/Count Binary Substrings.java | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Easy/Count Binary Substrings.java b/Easy/Count Binary Substrings.java
index ff2ee4b0..a0818c9f 100644
--- a/Easy/Count Binary Substrings.java	
+++ b/Easy/Count Binary Substrings.java	
@@ -1,19 +1,19 @@
 class Solution {
   public int countBinarySubstrings(String s) {
-    int currValueCount = 1;
-    int prevValueCount = 0;
-    int count = 0;
-    for (int i = 1; i < s.length(); i++) {
-      if (s.charAt(i) == s.charAt(i - 1)) {
-        currValueCount++;
+    int totalCount = 0;
+    int currCount = 0;
+    int oppositeCount = 0;
+    char currChar = s.charAt(0);
+    for (int i = 0; i < s.length(); i++) {
+      if (s.charAt(i) == currChar) {
+        currCount++;
       } else {
-        prevValueCount = currValueCount;
-        currValueCount = 1;
-      }
-      if (prevValueCount >= currValueCount) {
-        count++;
+        totalCount += Math.min(currCount, oppositeCount);
+        oppositeCount = currCount;
+        currCount = 1;
+        currChar = s.charAt(i);
       }
     }
-    return count;
+    return totalCount + Math.min(currCount, oppositeCount);
   }
 }

From ab4fb5c3fe960abc9b2cdc9f8d5079b376e71692 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Mar 2022 05:34:36 +0530
Subject: [PATCH 0895/2175] Create Find the Difference of Two Arrays.java

---
 Easy/Find the Difference of Two Arrays.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Find the Difference of Two Arrays.java

diff --git a/Easy/Find the Difference of Two Arrays.java b/Easy/Find the Difference of Two Arrays.java
new file mode 100644
index 00000000..fa061f5f
--- /dev/null
+++ b/Easy/Find the Difference of Two Arrays.java	
@@ -0,0 +1,9 @@
+class Solution {
+  public List<List<Integer>> findDifference(int[] nums1, int[] nums2) {
+    Set<Integer> setOne = Arrays.stream(nums1).boxed().collect(Collectors.toSet());
+    Set<Integer> setTwo = Arrays.stream(nums2).boxed().collect(Collectors.toSet());
+    return Arrays.asList(
+        setOne.stream().filter(e -> !setTwo.contains(e)).collect(Collectors.toList()),
+        setTwo.stream().filter(e -> !setOne.contains(e)).collect(Collectors.toList()));
+  }
+}

From c773c121f546ed990be8862528ed56976cab8add Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Mar 2022 09:04:52 +0530
Subject: [PATCH 0896/2175] Create Design Bounded Blocking Queue.java

---
 .../Design Bounded Blocking Queue.java        | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Concurrency/Design Bounded Blocking Queue.java

diff --git a/Concurrency/Design Bounded Blocking Queue.java b/Concurrency/Design Bounded Blocking Queue.java
new file mode 100644
index 00000000..a8e0a3d2
--- /dev/null
+++ b/Concurrency/Design Bounded Blocking Queue.java	
@@ -0,0 +1,42 @@
+class BoundedBlockingQueue {
+  
+  private final Queue<Integer> queue;
+  private final Semaphore mutex;
+  private final Semaphore items;
+  private final Semaphore capacityTracker;
+  private int currentCapacity;
+
+  public BoundedBlockingQueue(int capacity) {
+    this.queue = new LinkedList<>();
+    this.mutex = new Semaphore(1);
+    this.items = new Semaphore(0);
+    this.capacityTracker = new Semaphore(capacity);
+    this.currentCapacity = 0;
+  }
+
+  public void enqueue(int element) throws InterruptedException {
+    this.capacityTracker.acquire();
+    this.mutex.acquire();
+    this.queue.add(element);
+    this.currentCapacity++;
+    this.mutex.release();
+    this.items.release();
+  }
+
+  public int dequeue() throws InterruptedException {
+    this.items.acquire();
+    this.mutex.acquire();
+    int result = this.queue.remove();
+    this.currentCapacity--;
+    this.mutex.release();
+    this.capacityTracker.release();
+    return result;
+  }
+
+  public int size() throws InterruptedException {
+    this.mutex.acquire();
+    int currentSize = this.currentCapacity;
+    this.mutex.release();
+    return currentSize;
+  }
+}

From 066ff00ed89db4c787d779f3b96e7f65719909c2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Mar 2022 21:18:06 +0530
Subject: [PATCH 0897/2175] Update Search in Rotated Sorted Array II.java

---
 Medium/Search in Rotated Sorted Array II.java | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/Medium/Search in Rotated Sorted Array II.java b/Medium/Search in Rotated Sorted Array II.java
index 83c15734..65081528 100644
--- a/Medium/Search in Rotated Sorted Array II.java	
+++ b/Medium/Search in Rotated Sorted Array II.java	
@@ -2,34 +2,27 @@ class Solution {
   public boolean search(int[] nums, int target) {
     int start = 0;
     int end = nums.length - 1;
-    int mid = -1;
     while (start <= end) {
-      mid = (start + end) / 2;
+      int mid = (start + end) / 2;
       if (nums[mid] == target) {
         return true;
       }
-      // Either right side is sorted or left side is unsorted
       if (nums[mid] < nums[end] || nums[mid] < nums[start]) {
         if (target > nums[mid] && target <= nums[end]) {
           start = mid + 1;
-        }
-        else {
+        } else {
           end = mid - 1;
         }
-      }
-      // Either left side is sorted or right side is unsorted
-      else if (nums[mid] > nums[start] || nums[mid] > nums[end]) {
+      } else if (nums[mid] > nums[start] || nums[mid] > nums[end]) {
         if (target < nums[mid] && target >= nums[start]) {
           end = mid - 1;
-        }
-        else {
+        } else {
           start = mid + 1;
         }
-      }
-      else {
+      } else {
         end--;
       }
     }
     return false;
-  }   
+  }
 }

From f4076d1aee3badf4c35c1087a2576efbc625e4bd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Mar 2022 22:10:52 +0530
Subject: [PATCH 0898/2175] Create Longest Happy String.java

---
 Medium/Longest Happy String.java | 42 ++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Longest Happy String.java

diff --git a/Medium/Longest Happy String.java b/Medium/Longest Happy String.java
new file mode 100644
index 00000000..145fd638
--- /dev/null
+++ b/Medium/Longest Happy String.java	
@@ -0,0 +1,42 @@
+class Solution {
+  public String longestDiverseString(int a, int b, int c) {
+    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((o1, o2) -> o2[1] - o1[1]);
+    if (a > 0) {
+      priorityQueue.add(new int[]{0, a});
+    }
+    if (b > 0) {
+      priorityQueue.add(new int[]{1, b});
+    }
+    if (c > 0) {
+      priorityQueue.add(new int[]{2, c});
+    }
+    StringBuilder sb = new StringBuilder("zz");
+    while (!priorityQueue.isEmpty()) {
+      int[] temp = {-1, -1};
+      char peekChar = (char) ('a' + priorityQueue.peek()[0]);
+      if (peekChar == sb.charAt(sb.length() - 1) && 
+          peekChar == sb.charAt(sb.length() - 2)) {
+        temp[0] = priorityQueue.peek()[0];
+        temp[1] = priorityQueue.peek()[1];
+        priorityQueue.poll();
+        if (priorityQueue.isEmpty()) {
+          break;
+        }
+      }
+      peekChar = (char) ('a' + priorityQueue.peek()[0]);
+      if (peekChar != sb.charAt(sb.length() - 1) || 
+          peekChar != sb.charAt(sb.length() - 2)) {
+        int[] removed = priorityQueue.poll();
+        sb.append(peekChar);
+        removed[1]--;
+        if (removed[1] > 0) {
+          priorityQueue.add(removed);
+        }
+      }
+      if (temp[0] != -1) {
+        priorityQueue.add(temp);
+      }
+    }
+    return sb.substring(2).toString();
+  }
+}

From 93bc3b7ce1d6562d5bd66a8651935a91fd18e645 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Mar 2022 10:11:13 +0530
Subject: [PATCH 0899/2175] Create Minimum Deletions to Make Array
 Beautiful.java

---
 .../Minimum Deletions to Make Array Beautiful.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Minimum Deletions to Make Array Beautiful.java

diff --git a/Medium/Minimum Deletions to Make Array Beautiful.java b/Medium/Minimum Deletions to Make Array Beautiful.java
new file mode 100644
index 00000000..8567e813
--- /dev/null
+++ b/Medium/Minimum Deletions to Make Array Beautiful.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int minDeletion(int[] nums) {
+    int numOfDeletions = 0;
+    int prevNum = -1;
+    for (int num : nums) {
+      if (num == prevNum) {
+        numOfDeletions++;
+      } else {
+        prevNum = prevNum == -1 ? num : -1;
+      }
+    }
+    return prevNum == -1 ? numOfDeletions : numOfDeletions + 1;
+  }
+}

From dbf5f10f181595f8977e83536765b1d3a39786fb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Mar 2022 10:23:13 +0530
Subject: [PATCH 0900/2175] Update and rename Find the duplicate number.java to
 Find the Duplicate Number.java

---
 Medium/Find the Duplicate Number.java | 16 ++++++++++++++++
 Medium/Find the duplicate number.java | 20 --------------------
 2 files changed, 16 insertions(+), 20 deletions(-)
 create mode 100644 Medium/Find the Duplicate Number.java
 delete mode 100644 Medium/Find the duplicate number.java

diff --git a/Medium/Find the Duplicate Number.java b/Medium/Find the Duplicate Number.java
new file mode 100644
index 00000000..c4f5a541
--- /dev/null
+++ b/Medium/Find the Duplicate Number.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int findDuplicate(int[] nums) {
+    int slow = nums[0];
+    int fast = nums[0];
+    do {
+      slow = nums[slow];
+      fast = nums[nums[fast]];
+    } while (slow != fast);
+    slow = nums[0];
+    while (slow != fast) {
+      slow = nums[slow];
+      fast = nums[fast];
+    }
+    return fast;
+  }
+}
diff --git a/Medium/Find the duplicate number.java b/Medium/Find the duplicate number.java
deleted file mode 100644
index d05d0a60..00000000
--- a/Medium/Find the duplicate number.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-  public int findDuplicate(int[] nums) {
-    int tortoise = nums[0];
-    int hare = nums[0];
-    while(true) {
-      tortoise = nums[tortoise];
-      hare = nums[nums[hare]];
-      if (tortoise == hare) {
-        break;
-      }
-    }
-    int p1 = nums[0];
-    int p2 = tortoise;
-    while (p1 != p2) {
-      p1 = nums[p1];
-      p2 = nums[p2];
-    }
-    return p1;
-  }
-}

From ebc167fecb113569cac589d412a7bea50fb2f694 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Mar 2022 23:20:11 +0530
Subject: [PATCH 0901/2175] Update Path With Maximum Minimum Value.java

---
 Medium/Path With Maximum Minimum Value.java | 43 +++++++++------------
 1 file changed, 18 insertions(+), 25 deletions(-)

diff --git a/Medium/Path With Maximum Minimum Value.java b/Medium/Path With Maximum Minimum Value.java
index d2204779..31942850 100644
--- a/Medium/Path With Maximum Minimum Value.java	
+++ b/Medium/Path With Maximum Minimum Value.java	
@@ -1,34 +1,27 @@
 class Solution {
-  int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-  public int maximumMinimumPath(int[][] A) {
-    int rows = A.length;
-    int cols = A[0].length;
-    boolean[][] visited = new boolean[rows][cols];
-    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
-      public int compare(int[] p1, int[] p2) {
-        return p2[0] - p1[0];
-      }
-    });
-    int maxVal = A[0][0];
-    pq.add(new int[]{A[0][0], 0, 0});
-    visited[0][0] = true;
+  
+  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+  public int maximumMinimumPath(int[][] grid) {
+    PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o2[2] - o1[2]);
+    pq.add(new int[]{0, 0, grid[0][0]});
+    int numRows = grid.length;
+    int numCols = grid[0].length;
+    boolean[][] visited = new boolean[numRows][numCols];
     while (!pq.isEmpty()) {
       int[] removed = pq.poll();
-      int x = removed[1];
-      int y = removed[2];
-      maxVal = Math.min(maxVal, removed[0]);
-      if (x == rows - 1 && y == cols - 1) {
-        break;
+      if (removed[0] == numRows - 1 && removed[1] == numCols - 1) {
+        return removed[2];
       }
-      for (int[] dir : dirs) {
-        int newX = x + dir[0];
-        int newY = y + dir[1];
-        if (newX >= 0 && newY >= 0 && newX < rows && newY < cols && !visited[newX][newY]) {
-          pq.add(new int[]{A[newX][newY], newX, newY});
-          visited[newX][newY] = true;
+      visited[removed[0]][removed[1]] = true;
+      for (int[] dir : DIRS) {
+        int newX = removed[0] + dir[0];
+        int newY = removed[1] + dir[1];
+        if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && !visited[newX][newY]) {
+          pq.add(new int[]{newX, newY, Math.min(removed[2], grid[newX][newY])});
         }
       }
     }
-    return maxVal;
+    return -1;
   }
 }

From ee812ba77c0b4fd239e670b3376a4fd0b991eb8c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Mar 2022 23:34:14 +0530
Subject: [PATCH 0902/2175] Update Climbing Stairs.java

---
 Easy/Climbing Stairs.java | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/Easy/Climbing Stairs.java b/Easy/Climbing Stairs.java
index e35175f2..f2ff9386 100644
--- a/Easy/Climbing Stairs.java	
+++ b/Easy/Climbing Stairs.java	
@@ -1,20 +1,14 @@
 class Solution {
-  int[] memo;
   public int climbStairs(int n) {
     if (n == 1) {
       return 1;
     }
-    memo = new int[n + 1];
-    memo[1] = 1;
-    memo[2] = 2;
-    return helper(n);
-  }
-  
-  private int helper(int n) {
-    if (memo[n] != 0) {
-      return memo[n];
+    int[] dp = new int[n + 1];
+    dp[1] = 1;
+    dp[2] = 2;
+    for (int i = 3; i <= n; i++) {
+      dp[i] = dp[i - 1] + dp[i - 2];
     }
-    memo[n] = helper(n - 1) + helper(n - 2);
-    return memo[n];
+    return dp[n];
   }
 }

From 070bec9cc87ad938092c8796afefe3025baae390 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Mar 2022 23:54:36 +0530
Subject: [PATCH 0903/2175] Update and rename Easy/House Robber.java to
 Medium/House Robber.java

---
 Easy/House Robber.java   | 14 --------------
 Medium/House Robber.java | 14 ++++++++++++++
 2 files changed, 14 insertions(+), 14 deletions(-)
 delete mode 100644 Easy/House Robber.java
 create mode 100644 Medium/House Robber.java

diff --git a/Easy/House Robber.java b/Easy/House Robber.java
deleted file mode 100644
index 6ec92f46..00000000
--- a/Easy/House Robber.java	
+++ /dev/null
@@ -1,14 +0,0 @@
-class Solution {
-  public int rob(int[] nums) {
-    if (nums.length == 0) {
-      return 0;
-    }
-    int[] dp = new int[nums.length + 1];
-    dp[0] = 0;
-    dp[1] = nums[0];
-    for (int i = 1; i < nums.length; i++) {
-      dp[i + 1] = Math.max(dp[i], dp[i - 1] + nums[i]);
-    }
-    return dp[nums.length];
-  }
-}
diff --git a/Medium/House Robber.java b/Medium/House Robber.java
new file mode 100644
index 00000000..8837a99d
--- /dev/null
+++ b/Medium/House Robber.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int rob(int[] nums) {
+    if (nums.length == 1) {
+      return nums[0];
+    }
+    int[] dp = new int[nums.length];
+    dp[0] = nums[0];
+    dp[1] = Math.max(nums[0], nums[1]);
+    for (int i = 2; i < nums.length; i++) {
+      dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+    }
+    return dp[nums.length - 1];
+  }
+}

From f1ed2bc744460d93bb250754478241c9bacdaaf9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 30 Mar 2022 08:57:26 +0530
Subject: [PATCH 0904/2175] Update Search a 2D Matrix.java

---
 Medium/Search a 2D Matrix.java | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/Medium/Search a 2D Matrix.java b/Medium/Search a 2D Matrix.java
index bb5861eb..e7de2a1f 100644
--- a/Medium/Search a 2D Matrix.java	
+++ b/Medium/Search a 2D Matrix.java	
@@ -1,23 +1,18 @@
 class Solution {
   public boolean searchMatrix(int[][] matrix, int target) {
-    if (matrix.length == 0 || matrix[0].length == 0) {
-      return false;
-    }
     int rowIdx = matrix.length - 1;
     int colIdx = matrix[0].length - 1;
     while (rowIdx >= 0 && colIdx >= 0) {
-      int val = matrix[rowIdx][colIdx];
-      if (val == target) {
+      if (matrix[rowIdx][colIdx] == target) {
         return true;
       }
-      if (val >= matrix[rowIdx][0]) {
+      if (matrix[rowIdx][colIdx] > target) {
         colIdx--;
         if (colIdx < 0) {
           colIdx = matrix[0].length - 1;
           rowIdx--;
         }
-      }
-      else {
+      } else {
         rowIdx--;
       }
     }

From 1c0e419cb10f87c7d6fa6fb0e69ef6d577b07280 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 30 Mar 2022 17:14:50 +0530
Subject: [PATCH 0905/2175] Update Minimum Deletions to Make Character
 Frequencies Unique.java

---
 ... to Make Character Frequencies Unique.java | 32 +++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/Medium/Minimum Deletions to Make Character Frequencies Unique.java b/Medium/Minimum Deletions to Make Character Frequencies Unique.java
index f05bace6..f98fa559 100644
--- a/Medium/Minimum Deletions to Make Character Frequencies Unique.java	
+++ b/Medium/Minimum Deletions to Make Character Frequencies Unique.java	
@@ -1,25 +1,25 @@
 class Solution {
   public int minDeletions(String s) {
-    int[] frequencies = new int[26];
+    int[] frequency = new int[26];
     for (char c : s.toCharArray()) {
-      frequencies[c - 'a']++;
+      frequency[c - 'a']++;
     }
-    Arrays.sort(frequencies);
-    int expectedFrequency = frequencies[25];
-    int numOfDeletions = 0;
-    for (int i = 25; i >= 0; i--) {
-      if (frequencies[i] == 0) {
-        break;
-      }
-      if (frequencies[i] > expectedFrequency) {
-        numOfDeletions += frequencies[i] - expectedFrequency;
-      } else {
-        expectedFrequency = frequencies[i];
+    PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+    for (int freq : frequency) {
+      if (freq > 0) {
+        pq.add(freq);
       }
-      if (expectedFrequency > 0) {
-        expectedFrequency--;
+    }
+    int numOfDeletions = 0;
+    while (!pq.isEmpty()) {
+      int removedFreq = pq.poll();
+      if (!pq.isEmpty() && pq.peek() == removedFreq) {
+        numOfDeletions++;
+        if (removedFreq > 1) {
+          pq.add(removedFreq - 1);
+        }
       }
     }
     return numOfDeletions;
-  } 
+  }
 }

From 875122b45fa53ef16975862382f1ce5b2d403fcb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 30 Mar 2022 21:35:34 +0530
Subject: [PATCH 0906/2175] Update Remove Duplicates From Sorted Lists.java

---
 Easy/Remove Duplicates From Sorted Lists.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Easy/Remove Duplicates From Sorted Lists.java b/Easy/Remove Duplicates From Sorted Lists.java
index 53626725..fbd899d4 100644
--- a/Easy/Remove Duplicates From Sorted Lists.java	
+++ b/Easy/Remove Duplicates From Sorted Lists.java	
@@ -3,19 +3,19 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
   public ListNode deleteDuplicates(ListNode head) {
     ListNode curr = head;
     while (curr != null) {
-      if (curr.next != null && curr.val == curr.next.val) {
+      while (curr.next != null && curr.next.val == curr.val) {
         curr.next = curr.next.next;
       }
-      else {
-        curr = curr.next;
-      }
+      curr = curr.next;
     }
     return head;
   }

From b7f991fc70349fb80607a22a525724b7335ddbeb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 31 Mar 2022 21:05:41 +0530
Subject: [PATCH 0907/2175] Update Flip Game.java

---
 Easy/Flip Game.java | 35 ++++++++---------------------------
 1 file changed, 8 insertions(+), 27 deletions(-)

diff --git a/Easy/Flip Game.java b/Easy/Flip Game.java
index 727227e2..75a364a0 100644
--- a/Easy/Flip Game.java	
+++ b/Easy/Flip Game.java	
@@ -1,30 +1,11 @@
 class Solution {
-    public static List<String> generatePossibleNextMoves(String s) {
-        List<String> ans = new ArrayList<>();
-
-        if (s.length() < 2) {
-            return ans;
-        }
-
-        if (s.equals("--")) {
-            return ans;
-        }
-
-        int i = 0;
-        while (i < s.length()-1) {
-            if (s.charAt(i) == s.charAt(i+1) && s.charAt(i) == '+') {
-                StringBuilder sb = new StringBuilder();
-                sb.append(s.substring(0, i));
-                sb.append('-');
-                sb.append('-');
-                sb.append(s.substring(i+2));
-
-                ans.add(sb.toString());
-            }
-
-            i++;
-        }
-
-        return ans;
+  public List<String> generatePossibleNextMoves(String currentState) {
+    List<String> list = new ArrayList<>();
+    for (int i = 1; i < currentState.length(); i++) {
+      if (currentState.charAt(i) == '+' && currentState.charAt(i - 1) == '+') {
+        list.add(currentState.substring(0, i - 1) + "--" + currentState.substring(i + 1));
+      }
     }
+    return list;
+  }
 }

From 183aed558be71d9a28c180109e6f5548eae1afe8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 1 Apr 2022 10:33:58 +0530
Subject: [PATCH 0908/2175] Update LFU Cache.java

---
 Hard/LFU Cache.java | 156 +++++++++++++++++++++++++++-----------------
 1 file changed, 95 insertions(+), 61 deletions(-)

diff --git a/Hard/LFU Cache.java b/Hard/LFU Cache.java
index 588f7a60..4d52ade6 100644
--- a/Hard/LFU Cache.java	
+++ b/Hard/LFU Cache.java	
@@ -1,78 +1,112 @@
 class LFUCache {
 
-    private Map<Integer, Integer> valMap;
-    private Map<Integer, Integer> freqMap;
-    private Map<Integer, LinkedHashSet<Integer>> freqCountMap;
-    private int capacity;
-    private int minValue;
+  private final Map<Integer, Node> keyToNodeMap;
+  private final Map<Integer, Node[]> frequencyToNodeMap;
+  private final Map<Integer, Integer> keyToFrequencyMap;
+  private int capacity;
+  private int currentCapacity;
 
-    public LFUCache(int capacity) {
-        valMap = new HashMap<>();
-        freqMap = new HashMap<>();
-        freqCountMap = new HashMap<>();
-        this.capacity = capacity;
-        minValue = 0;
-    }
+  public LFUCache(int capacity) {
+    this.capacity = capacity;
+    this.currentCapacity = 0;
+    this.keyToNodeMap = new HashMap<>();
+    this.frequencyToNodeMap = new TreeMap<>();
+    this.keyToFrequencyMap = new HashMap<>();
+  }
 
-    public int get(int key) {
-        if (!valMap.containsKey(key)) {
-            return -1;
-        }
+  public int get(int key) {
+    if (!keyToNodeMap.containsKey(key)) {
+      return -1;
+    }
+    Node node = keyToNodeMap.get(key);
+    removeNode(node);
+    int currentFrequency = keyToFrequencyMap.get(key);
+    int newFrequency = currentFrequency + 1;
+    keyToFrequencyMap.put(key, newFrequency);
+    addNodeToFrequencyHead(node, newFrequency);
+    return node.val;
+  }
 
-        // Updating frequency
-        int oldFreq = freqMap.get(key);
-        freqMap.put(key, oldFreq + 1);
-        int newFreq = freqMap.get(key);
+  public void put(int key, int value) {
+    if (this.capacity == 0) {
+      return;
+    }
+    removeNodeIfCapacityReached(key);
+    Node node = getNode(key, value);
+    int newFrequency = keyToFrequencyMap.getOrDefault(key, 0) + 1;
+    keyToFrequencyMap.put(key, newFrequency);
+    keyToNodeMap.put(key, node);
+    if (newFrequency > 1) {
+      removeNode(node);
+    }
+    addNodeToFrequencyHead(node, newFrequency);
+  }
 
-        // Removing from old frequency set
-        LinkedHashSet<Integer> set = freqCountMap.get(oldFreq);
-        set.remove(key);
-        if (set.isEmpty()) {
-            // As this was the only key with min freq so minimum frequency should be updated
-            if (minValue == oldFreq) {
-                minValue = oldFreq + 1;
-            }
-            freqCountMap.remove(oldFreq);
-        }
-        else {
-            freqCountMap.put(oldFreq, set);
+  private void removeNodeIfCapacityReached(int key) {
+    if (!keyToNodeMap.containsKey(key) && this.currentCapacity == capacity) {
+      for (Integer freq : frequencyToNodeMap.keySet()) {
+        Node[] nodes = frequencyToNodeMap.get(freq);
+        if (nodes[1].prev.val == -1) {
+          continue;
         }
-
-        // Updating new frequency set
-        freqCountMap.computeIfAbsent(newFreq, k -> new LinkedHashSet<>()).add(key);
-
-        return valMap.get(key);
+        Node toRemove = nodes[1].prev;
+        removeNode(toRemove);
+        keyToNodeMap.remove(toRemove.key);
+        keyToFrequencyMap.remove(toRemove.key);
+        this.currentCapacity--;
+        break;
+      }
     }
+  }
 
-    public void put(int key, int value) {
-        if (capacity == 0) {
-            return;
-        }
-        
-        if (get(key) != -1) {
-            valMap.put(key, value);
-            return;
-        }
+  private Node getNode(int key, int value) {
+    Node node;
+    if (keyToNodeMap.containsKey(key)) {
+      node = keyToNodeMap.get(key);
+      removeNode(node);
+      node.val = value;
+    } else {
+      this.currentCapacity++;
+      node = new Node(value, key);
+    }
+    return node;
+  }
 
-        if (valMap.size() == capacity) {
-            LinkedHashSet<Integer> set = freqCountMap.get(minValue);
-            int keyToBeDeleted = set.iterator().next();
-            valMap.remove(keyToBeDeleted);
-            freqMap.remove(keyToBeDeleted);
-            set.remove(keyToBeDeleted);
+  private void addNodeToFrequencyHead(Node node, int newFrequency) {
+    if (!frequencyToNodeMap.containsKey(newFrequency)) {
+      Node head = new Node(-1, Integer.MIN_VALUE);
+      Node tail = new Node(-1, Integer.MAX_VALUE);
+      head.next = tail;
+      tail.prev = head;
+      frequencyToNodeMap.put(newFrequency, new Node[]{head, tail});
+    }
+    Node headNode = frequencyToNodeMap.get(newFrequency)[0];
+    Node nextToHead = headNode.next;
+    nextToHead.prev = node;
+    node.next = nextToHead;
+    headNode.next = node;
+    node.prev = headNode;
+  }
+  
+  private void removeNode(Node node) {
+    Node prevNode = node.prev;
+    Node nextNode = node.next;
+    prevNode.next = nextNode;
+    nextNode.prev = prevNode;
+  }
 
-            if (set.isEmpty()) {
-                freqCountMap.remove(minValue);
-            }
-        }
+  private static class Node {
+    int val;
+    int key;
+    Node next;
+    Node prev;
 
-        valMap.put(key, value);
-        freqMap.put(key, 1);
-        freqCountMap.computeIfAbsent(1, k -> new LinkedHashSet<>()).add(key);
-        minValue = 1;
+    public Node(int val, int key) {
+      this.val = val;
+      this.key = key;
     }
+  }
 }
-
 /**
  * Your LFUCache object will be instantiated and called as such:
  * LFUCache obj = new LFUCache(capacity);

From 2c237417a8d9b798ed6c38d6616b69a38c938eb8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 1 Apr 2022 17:12:45 +0530
Subject: [PATCH 0909/2175] Update Max Stack.java

---
 Easy/Max Stack.java | 82 +++++++++++++++++++++++++++++++++------------
 1 file changed, 60 insertions(+), 22 deletions(-)

diff --git a/Easy/Max Stack.java b/Easy/Max Stack.java
index 3125c3d0..e320e096 100644
--- a/Easy/Max Stack.java	
+++ b/Easy/Max Stack.java	
@@ -1,45 +1,83 @@
 class MaxStack {
 
-  /** initialize your data structure here. */
-  Stack<Integer> stack;
-  Stack<Integer> max;
+  private Node stackHead;
+  private Node stackTail;
+  private PriorityQueue<Integer> maxValues;
+  private Map<Integer, Stack<Node>> valToNodeMapping;
+
   public MaxStack() {
-    stack = new Stack<>();
-    max = new Stack<>();
+    this.stackHead = new Node(Integer.MIN_VALUE);
+    this.stackTail = new Node(Integer.MAX_VALUE);
+    this.stackTail.prev = this.stackHead;
+    this.stackHead.next = this.stackTail;
+    this.maxValues = new PriorityQueue<>((o1, o2) -> o2 - o1);
+    this.valToNodeMapping = new HashMap<>();
   }
 
   public void push(int x) {
-    stack.push(x);
-    max.push(max.isEmpty() ? x : Math.max(x, max.peek()));
+    Node node = new Node(x);
+    if (!this.valToNodeMapping.containsKey(x)) {
+      this.maxValues.add(x);
+    }
+    addNodeToStack(node);
+    this.valToNodeMapping.computeIfAbsent(x, k -> new Stack<>()).push(node);
   }
 
   public int pop() {
-    max.pop();
-    return stack.pop();
+    Node toRemove = this.stackHead.next;
+    this.valToNodeMapping.get(toRemove.val).pop();
+    removeNodeFromStack(toRemove);
+    return toRemove.val;
   }
 
   public int top() {
-    return stack.peek();
+    return this.stackHead.next.val;
   }
 
   public int peekMax() {
-    return max.peek();
+    moveToMaxValue();
+    int maxVal = this.maxValues.peek();
+    return this.valToNodeMapping.get(maxVal).peek().val;
   }
 
   public int popMax() {
-    int num = max.peek();
-    Stack<Integer> temp = new Stack<>();
-    while (stack.peek() != num) {
-      temp.push(stack.pop());
-      max.pop();
+    moveToMaxValue();
+    int maxVal = this.maxValues.peek();
+    Node toRemove = this.valToNodeMapping.get(maxVal).pop();
+    removeNodeFromStack(toRemove);
+    return toRemove.val;
+  }
+  
+  private void moveToMaxValue() {
+    while (this.valToNodeMapping.get(this.maxValues.peek()).isEmpty()) {
+      this.valToNodeMapping.remove(this.maxValues.poll());
     }
-    max.pop();
-    stack.pop();
-    while (!temp.isEmpty()) {
-      push(temp.pop());
+  }
+
+  private void addNodeToStack(Node node) {
+    Node nextToHead = this.stackHead.next;
+    nextToHead.prev = node;
+    node.next = nextToHead;
+    this.stackHead.next = node;
+    node.prev = this.stackHead;
+  }
+
+  private void removeNodeFromStack(Node node) {
+    Node nextNode = node.next;
+    Node prevNode = node.prev;
+    prevNode.next = nextNode;
+    nextNode.prev = prevNode;
+  }
+
+  private static class Node {
+    int val;
+    Node next;
+    Node prev;
+
+    public Node(int val) {
+      this.val = val;
     }
-    return num;
-  } 
+  }
 }
 
 /**

From 8a945a7197645e7a1601707bd23a3993e93d7fe5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Apr 2022 09:44:22 +0530
Subject: [PATCH 0910/2175] Update Valid Palindrome II.java

---
 Easy/Valid Palindrome II.java | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/Easy/Valid Palindrome II.java b/Easy/Valid Palindrome II.java
index c0edfc4c..a8627315 100644
--- a/Easy/Valid Palindrome II.java	
+++ b/Easy/Valid Palindrome II.java	
@@ -1,21 +1,26 @@
 class Solution {
   public boolean validPalindrome(String s) {
-    int[] firstPalindromeCheck = isPalindromHelper(s);
-    if (firstPalindromeCheck[0] == -1) {
-      return true;
-    }
-    int[] skipLeft = isPalindromHelper(s.substring(firstPalindromeCheck[0] + 1, firstPalindromeCheck[1] + 1));
-    int[] skipRight = isPalindromHelper(s.substring(firstPalindromeCheck[0], check[1]));
-    return skipLeft[0] == -1 || skipRight[0] == -1;
-  }
-
-  private int[] isPalindromHelper(String s) {
     int startIdx = 0;
     int endIdx = s.length() - 1;
-    while (startIdx < endIdx && s.charAt(startIdx) == s.charAt(endIdx)) {
+    while (startIdx < endIdx) {
+      if (s.charAt(startIdx) != s.charAt(endIdx)) {
+        return isPalindromeWithDeletion(s, startIdx + 1, endIdx) || 
+          isPalindromeWithDeletion(s, startIdx, endIdx - 1);
+      }
+      startIdx++;
+      endIdx--;
+    }
+    return true;
+  } 
+  
+  private boolean isPalindromeWithDeletion(String s, int startIdx, int endIdx) {
+    while (startIdx < endIdx) {
+      if (s.charAt(startIdx) != s.charAt(endIdx)) {
+        return false;
+      }
       startIdx++;
       endIdx--;
     }
-    return startIdx >= endIdx ? new int[]{-1} : new int[]{startIdx, endIdx};
+    return true;
   }
 }

From 9389da70efb6e9664ecee48de4d8aed9df26afad Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Apr 2022 12:00:48 +0530
Subject: [PATCH 0911/2175] Create Brace Expansion.java

---
 Medium/Brace Expansion.java | 47 +++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 Medium/Brace Expansion.java

diff --git a/Medium/Brace Expansion.java b/Medium/Brace Expansion.java
new file mode 100644
index 00000000..38f0d5a4
--- /dev/null
+++ b/Medium/Brace Expansion.java	
@@ -0,0 +1,47 @@
+class Solution {
+  public String[] expand(String s) {
+    List<List<String>> splits = parseInput(s);
+    List<String> result = new ArrayList<>();
+    StringBuilder sb = new StringBuilder();
+    helper(splits, result, sb, 0);
+    Collections.sort(result);
+    String[] answer = new String[result.size()];
+    for (int i = 0; i < result.size(); i++) {
+      answer[i] = result.get(i);
+    }
+    return answer;
+  }
+
+  private void helper(List<List<String>> splits, List<String> result, StringBuilder sb, int idx) {
+    if (idx >= splits.size()) {
+      if (sb.length() == splits.size()) {
+        result.add(new StringBuilder(sb.toString()).toString());
+      }
+    } else {
+      for (int i = idx; i < splits.size(); i++) {
+        List<String> currentSplit = splits.get(i);
+        for (String section : currentSplit) {
+          sb.append(section);
+          helper(splits, result, sb, i + 1);
+          sb.deleteCharAt(sb.length() - 1);
+        }
+      }
+    }
+  }
+
+  private List<List<String>> parseInput(String s) {
+    List<List<String>> splits = new ArrayList<>();
+    int idx = 0;
+    while (idx < s.length()) {
+      if (s.charAt(idx) == '{') {
+        int endIdx = s.indexOf('}', idx);
+        String[] segements = s.substring(idx + 1, endIdx).split(",");
+        splits.add(Arrays.asList(segements));
+        idx = endIdx + 1;
+      } else {
+        splits.add(List.of(String.valueOf(s.charAt(idx++))));
+      }
+    }
+    return splits;
+  }
+}

From 8bf6e50eda11c4dee38e14bc661837cab31c6f38 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Apr 2022 12:57:35 +0530
Subject: [PATCH 0912/2175] Update Min Stack.java

---
 Easy/Min Stack.java | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/Easy/Min Stack.java b/Easy/Min Stack.java
index 108f5e0c..70d88780 100644
--- a/Easy/Min Stack.java	
+++ b/Easy/Min Stack.java	
@@ -1,36 +1,32 @@
 class MinStack {
-
-    /** initialize your data structure here. */
-  Stack<Integer> stack;
-  Stack<Integer> min;
+  private final Stack<int[]> stack;
+  
   public MinStack() {
-    stack = new Stack<>();
-    min = new Stack<>();
-  }
+    this.stack = new Stack<>();
+  } 
 
-  public void push(int x) {
-    stack.push(x);
-    min.push(Math.min(x, min.isEmpty() ? Integer.MAX_VALUE : min.peek()));
+  public void push(int val) {
+    int min = stack.isEmpty() ? val : Math.min(val, stack.peek()[1]);
+    stack.push(new int[]{val, min});
   }
 
   public void pop() {
     stack.pop();
-    min.pop();
   }
 
   public int top() {
-    return stack.peek();
+    return stack.peek()[0];
   }
 
   public int getMin() {
-    return min.peek();
+    return stack.peek()[1];
   }
 }
 
 /**
  * Your MinStack object will be instantiated and called as such:
  * MinStack obj = new MinStack();
- * obj.push(x);
+ * obj.push(val);
  * obj.pop();
  * int param_3 = obj.top();
  * int param_4 = obj.getMin();

From 2b90fc1353a531bf8eb5d14e664749e7e71c5848 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Apr 2022 15:52:27 +0530
Subject: [PATCH 0913/2175] Update and rename Hard/Parallel Courses.java to
 Medium/Parallel Courses.java

---
 Hard/Parallel Courses.java   | 46 ------------------------------------
 Medium/Parallel Courses.java | 33 ++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 46 deletions(-)
 delete mode 100644 Hard/Parallel Courses.java
 create mode 100644 Medium/Parallel Courses.java

diff --git a/Hard/Parallel Courses.java b/Hard/Parallel Courses.java
deleted file mode 100644
index f2470294..00000000
--- a/Hard/Parallel Courses.java	
+++ /dev/null
@@ -1,46 +0,0 @@
-class Solution {
-    public int minimumSemesters(int N, int[][] relations) {
-        Map<Integer, List<Integer>> map = new HashMap<>();
-        // A prerequisite counter for each course
-        int[] prereqs = new int[N + 1];
-        
-        for (int[] relation : relations) {
-            map.computeIfAbsent(relation[0], k-> new ArrayList<>()).add(relation[1]);
-            prereqs[relation[1]]++;
-        }
-        
-        Queue<Integer> queue = new LinkedList<>();
-        
-        // Add all the courses which have no prerequisite
-        // So that we can take those courses in first semester
-        for (int i = 1; i <= N; i++) {
-            if (prereqs[i] == 0) {
-                queue.add(i);
-            }
-        }
-        
-        int semester = 0;
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            while (size-- > 0) {
-                int course = queue.poll();
-                // Decrement N as we have taken a course that is removed from the queue
-                N--;
-                for (int pre : map.getOrDefault(course, new ArrayList<>())) {
-                    /*
-                    If a course which depends upon the removed course had only the removed course as prereq then we can
-                    add it to the queue
-                    */
-                    if (--prereqs[pre] == 0) {
-                        queue.add(pre);
-                    }
-                }
-            }
-            
-            // Semester over. New semester starts
-            semester++;
-        }
-
-        return N == 0 ? semester : -1;
-    }
-}
diff --git a/Medium/Parallel Courses.java b/Medium/Parallel Courses.java
new file mode 100644
index 00000000..a3843f23
--- /dev/null
+++ b/Medium/Parallel Courses.java	
@@ -0,0 +1,33 @@
+class Solution {
+  public int minimumSemesters(int n, int[][] relations) {
+    Map<Integer, List<Integer>> graph = new HashMap<>();
+    int[] indegree = new int[n + 1];
+    for (int[] relation : relations) {
+      graph.computeIfAbsent(relation[0], k -> new ArrayList<>()).add(relation[1]);
+      indegree[relation[1]]++;
+    }
+    Queue<Integer> queue = new LinkedList<>();
+    int numOfSemesters = 0;
+    Set<Integer> coursesTaken = new HashSet<>();
+    for (int i = 1; i <= n; i++) {
+      if (indegree[i] == 0) {
+        queue.add(i);
+      }
+    }
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int course = queue.remove();
+        coursesTaken.add(course);
+        for (int dependentCourse : graph.getOrDefault(course, new ArrayList<>())) {
+          indegree[dependentCourse]--;
+          if (indegree[dependentCourse] <= 0 && !coursesTaken.contains(dependentCourse)) {
+            queue.add(dependentCourse);
+          }
+        }
+      }
+      numOfSemesters++;
+    }
+    return coursesTaken.size() == n ? numOfSemesters : -1;
+  }
+}

From 4ebe08e4fc836a6d308da895204e4335d7d224f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Apr 2022 10:50:31 +0530
Subject: [PATCH 0914/2175] Create Minimum Bit Flips to Convert Number.java

---
 Easy/Minimum Bit Flips to Convert Number.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Minimum Bit Flips to Convert Number.java

diff --git a/Easy/Minimum Bit Flips to Convert Number.java b/Easy/Minimum Bit Flips to Convert Number.java
new file mode 100644
index 00000000..d3e2da78
--- /dev/null
+++ b/Easy/Minimum Bit Flips to Convert Number.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int minBitFlips(int start, int goal) {
+    int numOfFlips = 0;
+    while (start > 0 && goal > 0) {
+      numOfFlips += start % 2 != goal % 2 ? 1 : 0;
+      start /= 2;
+      goal /= 2;
+    }
+    while (start > 0) {
+      numOfFlips += start % 2;
+      start /= 2;
+    }
+    while (goal > 0) {
+      numOfFlips += goal % 2;
+      goal /= 2;
+    }
+    return numOfFlips;
+  }
+}

From 6f4684b8ec975d378d81911f2744b9579bb4988e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Apr 2022 10:56:54 +0530
Subject: [PATCH 0915/2175] Create Minimum Number of Operations to Convert
 Time.java

---
 ...um Number of Operations to Convert Time.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Minimum Number of Operations to Convert Time.java

diff --git a/Easy/Minimum Number of Operations to Convert Time.java b/Easy/Minimum Number of Operations to Convert Time.java
new file mode 100644
index 00000000..8a5f1db2
--- /dev/null
+++ b/Easy/Minimum Number of Operations to Convert Time.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int convertTime(String current, String correct) {
+    int minutesDiff = getMinutes(correct) - getMinutes(current);
+    int numOfOperations = 0;
+    int[] incrementFactors = {60, 15, 5, 1};
+    for (int i = 0; i < incrementFactors.length; i++) {
+      numOfOperations += minutesDiff / incrementFactors[i];
+      minutesDiff %= incrementFactors[i];
+    }
+    return numOfOperations;
+  }
+
+  private int getMinutes(String time) {
+    String[] split = time.split(":");
+    return Integer.parseInt(split[0]) * 60 + Integer.parseInt(split[1]);
+  }
+}

From 30b1345526411b480d2c77c7d8ce55968a7a9ed4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Apr 2022 14:26:25 +0530
Subject: [PATCH 0916/2175] Create Find Players With Zero or One Losses.java

---
 .../Find Players With Zero or One Losses.java | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Find Players With Zero or One Losses.java

diff --git a/Medium/Find Players With Zero or One Losses.java b/Medium/Find Players With Zero or One Losses.java
new file mode 100644
index 00000000..f3f14ff5
--- /dev/null
+++ b/Medium/Find Players With Zero or One Losses.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public List<List<Integer>> findWinners(int[][] matches) {
+    Map<Integer, Integer> lossCount = new HashMap<>();
+    Set<Integer> players = new HashSet<>();
+    for (int[] match : matches) {
+      lossCount.put(match[1], lossCount.getOrDefault(match[1], 0) + 1);
+      players.add(match[0]);
+      players.add(match[1]);
+    }
+    List<Integer> noLoss = new ArrayList<>();
+    List<Integer> exactlyOneLoss = new ArrayList<>();
+    for (Integer player : players) {
+      if (!lossCount.containsKey(player)) {
+        noLoss.add(player);
+      }
+      if (lossCount.getOrDefault(player, 0) == 1) {
+        exactlyOneLoss.add(player);
+      }
+    }
+    Collections.sort(noLoss);
+    Collections.sort(exactlyOneLoss);
+    return Arrays.asList(noLoss, exactlyOneLoss);
+  }
+}

From 979fdd6146bdbe91b287260a8822f0e2255f78f3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Apr 2022 12:03:57 +0530
Subject: [PATCH 0917/2175] Update Swapping Nodes in a Linked List.java

---
 Medium/Swapping Nodes in a Linked List.java | 46 +++++++++++++++------
 1 file changed, 34 insertions(+), 12 deletions(-)

diff --git a/Medium/Swapping Nodes in a Linked List.java b/Medium/Swapping Nodes in a Linked List.java
index e16f50b1..8fdf72f4 100644
--- a/Medium/Swapping Nodes in a Linked List.java	
+++ b/Medium/Swapping Nodes in a Linked List.java	
@@ -10,22 +10,44 @@
  */
 class Solution {
   public ListNode swapNodes(ListNode head, int k) {
-    ListNode fast = null;
+    int listLength = 0;
     ListNode curr = head;
-    int currCount = 1;
-    while (currCount != k) {
+    while (curr != null) {
+      listLength++;
       curr = curr.next;
-      currCount++;
     }
-    fast = curr;
-    ListNode slow = head;
-    while (curr.next != null) {
-      slow = slow.next;
-      curr = curr.next;
+    ListNode startPrev = null;
+    ListNode start = head;
+    ListNode endPrev = null;
+    ListNode end = head;
+    int count = k - 1;
+    while (count > 0) {
+      startPrev = start;
+      start = start.next;
+      count--;
+    }
+    count = listLength - k;
+    while (count > 0) {
+      endPrev = end;
+      end = end.next;
+      count--;
+    }
+    if (startPrev != null) {
+      startPrev.next = end;
+    }
+    if (endPrev != null) {
+      endPrev.next = start;
+    }
+    ListNode temp = start.next;
+    start.next = end.next;
+    end.next = temp;
+    // Updating head pointers if required
+    if (k == 1) {
+      head = end;
+    } 
+    if (k == listLength) {
+      head = start;
     }
-    int temp = fast.val;
-    fast.val = slow.val;
-    slow.val = temp;
     return head;
   }
 }

From e4260f92f0662617d1038efad6bb691e88630370 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Apr 2022 19:38:56 +0530
Subject: [PATCH 0918/2175] Create Find Triangular Sum of an Array.java

---
 Medium/Find Triangular Sum of an Array.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Find Triangular Sum of an Array.java

diff --git a/Medium/Find Triangular Sum of an Array.java b/Medium/Find Triangular Sum of an Array.java
new file mode 100644
index 00000000..0da1ef52
--- /dev/null
+++ b/Medium/Find Triangular Sum of an Array.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int triangularSum(int[] nums) {
+    int n = nums.length;
+    while (n > 1) {
+      for (int i = 0; i + 1 < n; i++) {
+        nums[i] = (nums[i] + nums[i + 1]) % 10;
+      }
+      n--;
+    }
+    return nums[0];
+  }
+}

From 1e41ec3004df116a68f4614be1df47ed9ccea18b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Apr 2022 23:25:49 +0530
Subject: [PATCH 0919/2175] Update Course Schedule II.java

---
 Medium/Course Schedule II.java | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/Medium/Course Schedule II.java b/Medium/Course Schedule II.java
index 4dc8b847..78fb8e08 100644
--- a/Medium/Course Schedule II.java	
+++ b/Medium/Course Schedule II.java	
@@ -1,29 +1,30 @@
 class Solution {
   public int[] findOrder(int numCourses, int[][] prerequisites) {
-    Map<Integer, List<Integer>> map = new HashMap<>();
-    int[] prereqCount = new int[numCourses];
+    Map<Integer, List<Integer>> prerequisiteToCourseDependency = new HashMap<>();
+    int[] prerequisiteCount = new int[numCourses];
     for (int[] prerequisite : prerequisites) {
-      prereqCount[prerequisite[0]]++;
-      map.computeIfAbsent(prerequisite[1], k -> new ArrayList<>()).add(prerequisite[0]);
+      prerequisiteToCourseDependency.computeIfAbsent(prerequisite[1], k -> new ArrayList<>())
+        .add(prerequisite[0]);
+      prerequisiteCount[prerequisite[0]]++;
     }
     Queue<Integer> queue = new LinkedList<>();
     for (int i = 0; i < numCourses; i++) {
-      if (prereqCount[i] == 0) {
+      if (prerequisiteCount[i] == 0) {
         queue.add(i);
       }
     }
-    int[] ans = new int[numCourses];
-    int idx = 0;
+    int[] courseOrder = new int[numCourses];
+    int courseOrderIdx = 0;
     while (!queue.isEmpty()) {
-      int removed = queue.remove();
-      for (Integer dependentCourse : map.getOrDefault(removed, new ArrayList<>())) {
-        prereqCount[dependentCourse]--;
-        if (prereqCount[dependentCourse] == 0) {
+      int course = queue.remove();
+      courseOrder[courseOrderIdx++] = course;
+      for (Integer dependentCourse : prerequisiteToCourseDependency.getOrDefault(course, new ArrayList<>())) {
+        prerequisiteCount[dependentCourse]--;
+        if (prerequisiteCount[dependentCourse] == 0) {
           queue.add(dependentCourse);
         }
       }
-      ans[idx++] = removed;
     }
-    return idx == numCourses ? ans : new int[]{};
+    return courseOrderIdx == numCourses ? courseOrder : new int[]{};
   }
 }

From 0772a03dec973be1f7ae35a9ec0ba762a84cfa01 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Apr 2022 23:47:48 +0530
Subject: [PATCH 0920/2175] Update Diameter of N-ary Tree.java

---
 Medium/Diameter of N-ary Tree.java | 34 +++++++++++++++---------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/Medium/Diameter of N-ary Tree.java b/Medium/Diameter of N-ary Tree.java
index 96ac97a5..7bf358a5 100644
--- a/Medium/Diameter of N-ary Tree.java	
+++ b/Medium/Diameter of N-ary Tree.java	
@@ -23,28 +23,28 @@ public Node(int _val,ArrayList<Node> _children) {
 
 class Solution {
   public int diameter(Node root) {
-    int[] max = {0};
-    helper(root, max);
-    return max[0];
+    int[] diameter = {0};
+    getHeight(root, diameter);
+    return diameter[0];
   }
   
-  private int helper(Node root, int[] max) {
-    if (root == null) {
+  private int getHeight(Node node, int[] diameter) {
+    if (node.children.size() == 0) {
       return 0;
     }
-    int max1 = 0;
-    int max2 = 0;
-    for (Node child : root.children) {
-      int height = helper(child, max);
-      if (max1 < height) {
-        max2 = max1;
-        max1 = height;
-      }
-      else if (max2 < height) {
-        max2 = height;
+    int maxHeightOne = 0;
+    int maxHeightTwo = 0;
+    for (Node child : node.children) {
+      int parentHeight = getHeight(child, diameter) + 1;
+      if (parentHeight > maxHeightOne) {
+        maxHeightTwo = maxHeightOne;
+        maxHeightOne = parentHeight;
+      } else if (parentHeight > maxHeightTwo) {
+        maxHeightTwo = parentHeight;
       }
+      int currentDiameter = maxHeightOne + maxHeightTwo;
+      diameter[0] = Math.max(diameter[0], currentDiameter);
     }
-    max[0] = Math.max(max[0], max1 + max2);
-    return max1 + 1;
+    return maxHeightOne;
   }
 }

From 274ebd75bfc4a2d7c39554c08853a0a9284c2f02 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Apr 2022 08:52:04 +0530
Subject: [PATCH 0921/2175] Update Container With Most Water.java

---
 Medium/Container With Most Water.java | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/Medium/Container With Most Water.java b/Medium/Container With Most Water.java
index cbfacba0..17fc1799 100644
--- a/Medium/Container With Most Water.java	
+++ b/Medium/Container With Most Water.java	
@@ -1,17 +1,18 @@
 class Solution {
   public int maxArea(int[] height) {
-    int maxWater = 0;
-    int start = 0;
-    int end = height.length - 1;
-    while (start < end) {
-      int minHeight = Math.min(height[start], height[end]);
-      maxWater = Math.max(maxWater, minHeight * (end - start));
-      if (height[start] > height[end]) {
-        end--;
+    int maximumArea = 0;
+    int leftIdx = 0;
+    int rightIdx = height.length - 1;
+    while (leftIdx < rightIdx) {
+      int maxHeight = Math.min(height[leftIdx], height[rightIdx]);
+      int currArea = maxHeight * (rightIdx - leftIdx);
+      maximumArea = Math.max(currArea, maximumArea);
+      if (maxHeight == height[leftIdx]) {
+        leftIdx++;
       } else {
-        start++;
+        rightIdx--;
       }
     }
-    return maxWater;
+    return maximumArea;
   }
 }

From 328a063b06c410439d6af2d0d3b868b523a77537 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Apr 2022 14:01:54 +0530
Subject: [PATCH 0922/2175] Update Rank Teams by Votes.java

---
 Medium/Rank Teams by Votes.java | 37 ++++++++++++++-------------------
 1 file changed, 16 insertions(+), 21 deletions(-)

diff --git a/Medium/Rank Teams by Votes.java b/Medium/Rank Teams by Votes.java
index f7ced0c6..e3cf32af 100644
--- a/Medium/Rank Teams by Votes.java	
+++ b/Medium/Rank Teams by Votes.java	
@@ -1,32 +1,27 @@
 class Solution {
   public String rankTeams(String[] votes) {
-    Map<Character, int[]> map = new HashMap<>();
-    int n = votes[0].length();
-    for(String vote : votes) {
-      for (int i = 0; i < n; i++) {
-        if (!map.containsKey(vote.charAt(i))) {
-          map.put(vote.charAt(i), new int[n]);
-        }
-        map.get(vote.charAt(i))[i]++;
+    Map<Character, Map<Integer, Integer>> map = new HashMap<>();
+    int positionCount = votes[0].length();
+    for (String vote : votes) {
+      for (int i = 0; i < vote.length(); i++) {
+        char c = vote.charAt(i);
+        map.computeIfAbsent(c, k -> new HashMap<>());
+        map.get(c).put(i, map.get(c).getOrDefault(i, 0) + 1);
       }
     }
-    PriorityQueue<Character> pq = new PriorityQueue<>(new Comparator<Character>(){
-      public int compare(Character c1, Character c2) {
-        for (int i = 0; i < n; i++) {
-          int c = map.get(c2)[i] - map.get(c1)[i];
-          if (c != 0) {
-            return c;
-          }
+    PriorityQueue<Character> priorityQueue = new PriorityQueue<>((o1, o2) -> {
+      for (int i = 0; i < positionCount; i++) {
+        int c = map.get(o2).getOrDefault(i, 0) - map.get(o1).getOrDefault(i, 0);
+        if (c != 0) {
+          return c;
         }
-        return c1 - c2;
       }
+      return o1 - o2;
     });
-    for (char c : votes[0].toCharArray()) {
-      pq.add(c);
-    }
+    priorityQueue.addAll(map.keySet());
     StringBuilder sb = new StringBuilder();
-    while (!pq.isEmpty()) {
-      sb.append(pq.poll());
+    while (!priorityQueue.isEmpty()) {
+      sb.append(priorityQueue.poll());
     }
     return sb.toString();
   }

From 2e8bd9e98c42ced01c8f765b27cf07e8f9b11a0d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Apr 2022 19:46:25 +0530
Subject: [PATCH 0923/2175] Update Convert Binary Search Tree to Sorted Doubly
 Linked List.java

---
 ...rch Tree to Sorted Doubly Linked List.java | 42 +++++++++++--------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/Medium/Convert Binary Search Tree to Sorted Doubly Linked List.java b/Medium/Convert Binary Search Tree to Sorted Doubly Linked List.java
index 838934c9..eaf92f02 100644
--- a/Medium/Convert Binary Search Tree to Sorted Doubly Linked List.java	
+++ b/Medium/Convert Binary Search Tree to Sorted Doubly Linked List.java	
@@ -20,27 +20,35 @@ public Node(int _val,Node _left,Node _right) {
 */
 
 class Solution {
-  Node prev;
   public Node treeToDoublyList(Node root) {
     if (root == null) {
       return root;
     }
-    Node dummy = new Node(0);
-    prev = dummy;
-    helper(root);
-    prev.right = dummy.right;
-    dummy.right.left = prev;
-    return dummy.right;
-  }
-  
-  private void helper(Node root) {
-    if (root == null) {
-      return;
+    Stack<Node> stack = new Stack<>();
+    while (root != null) {
+      stack.push(root);
+      root = root.left;
+    }
+    Node head = null;
+    Node prev = null;
+    while (!stack.isEmpty()) {
+      Node removed = stack.pop();
+      Node rightNode = removed.right;
+      while (rightNode != null) {
+        stack.push(rightNode);
+        rightNode = rightNode.left;
+      }
+      if (head == null) {
+        head = removed;
+      }
+      if (prev != null) {
+        prev.right = removed;
+      }
+      removed.left = prev;
+      prev = removed;
     }
-    helper(root.left);
-    prev.right = root;
-    root.left = prev;
-    prev = root;
-    helper(root.right); 
+    head.left = prev;
+    prev.right = head;
+    return head;
   }
 }

From 0a8e11590d1aef88339e18d69b4a26dd39901193 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Apr 2022 20:48:42 +0530
Subject: [PATCH 0924/2175] Create Fizz Buzz Multithreaded.java

---
 Concurrency/Fizz Buzz Multithreaded.java | 77 ++++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 Concurrency/Fizz Buzz Multithreaded.java

diff --git a/Concurrency/Fizz Buzz Multithreaded.java b/Concurrency/Fizz Buzz Multithreaded.java
new file mode 100644
index 00000000..2e213c7c
--- /dev/null
+++ b/Concurrency/Fizz Buzz Multithreaded.java	
@@ -0,0 +1,77 @@
+class FizzBuzz {
+  private int n;
+  private int count;
+  private Semaphore fizz;
+  private Semaphore buzz;
+  private Semaphore fizzBuzz;
+  private Semaphore number;
+
+  public FizzBuzz(int n) {
+    this.n = n;
+    this.count = 1;
+    this.fizz = new Semaphore(0);
+    this.buzz = new Semaphore(0);
+    this.fizzBuzz = new Semaphore(0);
+    this.number = new Semaphore(1);
+  }
+
+  // printFizz.run() outputs "fizz".
+  public void fizz(Runnable printFizz) throws InterruptedException {
+    while (this.count <= this.n) {
+      if (this.count % 3 == 0 && this.count % 5 != 0) {
+        this.fizz.acquire();
+        printFizz.run();
+        this.count++;
+        releaseLock(this.count);
+      }
+    }
+  }
+
+  // printBuzz.run() outputs "buzz".
+  public void buzz(Runnable printBuzz) throws InterruptedException {
+    while (this.count <= this.n) {
+      if (this.count % 3 != 0 && this.count % 5 == 0) {
+        this.buzz.acquire();
+        printBuzz.run();
+        this.count++;
+        releaseLock(this.count);
+      }
+    }
+  }
+
+  // printFizzBuzz.run() outputs "fizzbuzz".
+  public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
+    while (this.count <= this.n) {
+      if (this.count % 3 == 0 && this.count % 5 == 0) {
+        this.fizzBuzz.acquire();
+        printFizzBuzz.run();
+        this.count++;
+        releaseLock(this.count);
+      }
+    }
+  }
+
+  // printNumber.accept(x) outputs "x", where x is an integer.
+  public void number(IntConsumer printNumber) throws InterruptedException {
+    while (this.count <= this.n) {
+      if (this.count % 3 != 0 && this.count % 5 != 0) {
+        this.number.acquire();
+        printNumber.accept(this.count);
+        this.count++;
+        releaseLock(this.count);
+      }
+    }
+  }
+  
+  private void releaseLock(int n) {
+    if (n % 15 == 0) {
+      this.fizzBuzz.release();
+    } else if (n % 3 == 0) {
+      this.fizz.release();
+    } else if (n % 5 == 0) {
+      this.buzz.release();
+    } else {
+      this.number.release();
+    }
+  }
+}

From 2f1c3ee65fd086eb5da32f69f641e090a9827b5a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Apr 2022 22:30:27 +0530
Subject: [PATCH 0925/2175] Create The Dining Philosophers.java

---
 Concurrency/The Dining Philosophers.java | 51 ++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 Concurrency/The Dining Philosophers.java

diff --git a/Concurrency/The Dining Philosophers.java b/Concurrency/The Dining Philosophers.java
new file mode 100644
index 00000000..01409d64
--- /dev/null
+++ b/Concurrency/The Dining Philosophers.java	
@@ -0,0 +1,51 @@
+class DiningPhilosophers {
+  
+  private List<Semaphore> forks;
+  private Semaphore dinersOnTable;
+  private List<String> state;
+  
+  public DiningPhilosophers() {
+    this.forks = new ArrayList<>();
+    this.state = new ArrayList<>();
+    for (int i = 0; i < 5; i++) {
+      this.forks.add(new Semaphore(1));
+      this.state.add("idle");
+    }
+    this.dinersOnTable = new Semaphore(4);
+  }
+
+  // call the run() method of any runnable to execute its code
+  public void wantsToEat(int philosopher,
+                         Runnable pickLeftFork,
+                         Runnable pickRightFork,
+                         Runnable eat,
+                         Runnable putLeftFork,
+                         Runnable putRightFork) throws InterruptedException {
+    int leftForkIdx = philosopher;
+    int rightForkIdx = (philosopher + 4) % 5;
+    
+    this.dinersOnTable.acquire();
+    if (this.state.get(philosopher).equals("eating")) {
+      this.dinersOnTable.release();
+      return;
+    }
+    this.state.set(philosopher, "eating");
+    pickFork(leftForkIdx, pickLeftFork);
+    pickFork(rightForkIdx, pickRightFork);
+    eat.run();
+    putFork(rightForkIdx, putRightFork);
+    putFork(leftForkIdx, putLeftFork);
+    this.state.set(philosopher, "idle");
+    this.dinersOnTable.release();
+  }
+  
+  private void putFork(int idx, Runnable put) {
+    put.run();
+    this.forks.get(idx).release();
+  }
+  
+  private void pickFork(int idx, Runnable pick) throws InterruptedException  {
+    this.forks.get(idx).acquire();
+    pick.run();
+  }
+}

From 01c7d2c13a410f366181d2fda0a2cd71bcf955b2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Apr 2022 08:44:32 +0530
Subject: [PATCH 0926/2175] Update 3Sum.java

---
 Medium/3Sum.java | 33 +++++++++++++--------------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/Medium/3Sum.java b/Medium/3Sum.java
index e959d745..d054e15a 100644
--- a/Medium/3Sum.java
+++ b/Medium/3Sum.java
@@ -1,29 +1,22 @@
 class Solution {
   public List<List<Integer>> threeSum(int[] nums) {
     Arrays.sort(nums);
-    List<List<Integer>> list = new ArrayList<>();
+    List<List<Integer>> result = new ArrayList<>();
     for (int i = 0; i < nums.length && nums[i] <= 0; i++) {
       if (i == 0 || nums[i - 1] != nums[i]) {
-        twoSumHelper(nums, i, list);
-      }
-    }
-    return list;
-  }
-  
-  private void twoSumHelper(int[] nums, int i, List<List<Integer>> list) {
-    int low = i + 1;
-    int high = nums.length - 1;
-    while (low < high) {
-      int sum = nums[i] + nums[low] + nums[high];
-      if (sum < 0 || (low > i + 1 && nums[low] == nums[low - 1])) {
-        low++;
-      }
-      else if (sum > 0 || (high < nums.length - 1 && nums[high] == nums[high + 1])) {
-        high--;
-      }
-      else {
-        list.add(Arrays.asList(nums[i], nums[low++], nums[high--]));
+        Set<Integer> set = new HashSet<>();
+        for (int j = i + 1; j < nums.length; j++) {
+          int target = -1 * (nums[i] + nums[j]);
+          if (set.contains(target)) {
+            result.add(Arrays.asList(nums[i], nums[j], target));
+            while (j + 1 < nums.length && nums[j] == nums[j + 1]) {
+              j++;
+            }
+          }
+          set.add(nums[j]);
+        }
       }
     }
+    return result;
   }
 }

From 21c5b71ac7ccd89a84717f1cf9bead61012519b4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Apr 2022 08:57:52 +0530
Subject: [PATCH 0927/2175] Create 3Sum With Multiplicity.java

---
 Medium/3Sum With Multiplicity.java | 37 ++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/3Sum With Multiplicity.java

diff --git a/Medium/3Sum With Multiplicity.java b/Medium/3Sum With Multiplicity.java
new file mode 100644
index 00000000..ca9315b3
--- /dev/null
+++ b/Medium/3Sum With Multiplicity.java	
@@ -0,0 +1,37 @@
+class Solution {
+  public int threeSumMulti(int[] nums, int target) {
+    Arrays.sort(nums);
+    long answer = 0;
+    for (int i = 0; i < nums.length; i++) {
+      int updatedTarget = target - nums[i];
+      int startIdx = i + 1;
+      int endIdx = nums.length - 1;
+      while (startIdx < endIdx) {
+        if (nums[startIdx] + nums[endIdx] < updatedTarget) {
+          startIdx++;
+        } else if (nums[startIdx] + nums[endIdx] > updatedTarget) {
+          endIdx--;
+        } else if (nums[startIdx] != nums[endIdx]) {
+          int leftIdx = 1;
+          int rightIdx = 1;
+          while (startIdx + 1 < endIdx && nums[startIdx] == nums[startIdx + 1]) {
+              leftIdx++;
+              startIdx++;
+          }
+          while (endIdx - 1 > startIdx && nums[endIdx] == nums[endIdx - 1]) {
+              rightIdx++;
+              endIdx--;
+          }
+
+          answer = (answer + leftIdx * rightIdx) % 1000000007;
+          startIdx++;
+          endIdx--;
+        } else {
+          answer = (answer + ((endIdx - startIdx + 1) * (endIdx - startIdx) / 2)) % 1000000007;
+          break;
+        }
+      }
+    }
+    return (int) answer;
+  }
+}

From 1bf1b998160cfb15c9108700bae181ae200e863c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Apr 2022 16:58:41 +0530
Subject: [PATCH 0928/2175] Create Building H2O.java

---
 Concurrency/Building H2O.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Concurrency/Building H2O.java

diff --git a/Concurrency/Building H2O.java b/Concurrency/Building H2O.java
new file mode 100644
index 00000000..4d2a6a84
--- /dev/null
+++ b/Concurrency/Building H2O.java	
@@ -0,0 +1,26 @@
+class H2O {
+  private Semaphore hydrogen;
+  private Semaphore oxygen;
+  private Semaphore mutex;
+
+  public H2O() {
+    this.hydrogen = new Semaphore(2);
+    this.oxygen = new Semaphore(0);
+    this.mutex = new Semaphore(1);
+  }
+
+  public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+    // releaseHydrogen.run() outputs "H". Do not change or remove this line.
+    this.hydrogen.acquire();
+    releaseHydrogen.run();
+    this.oxygen.release();
+  }
+
+  public void oxygen(Runnable releaseOxygen) throws InterruptedException {
+    this.mutex.acquire();
+    this.oxygen.acquire(2);
+    releaseOxygen.run();
+    this.hydrogen.release(2);
+    this.mutex.release();
+  }
+}

From a14f47a2bc1e24392340201253644b0eb99b2248 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Apr 2022 11:46:46 +0530
Subject: [PATCH 0929/2175] Update Last Stone Weight.java

---
 Easy/Last Stone Weight.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Easy/Last Stone Weight.java b/Easy/Last Stone Weight.java
index abf2a4d9..08f390b1 100644
--- a/Easy/Last Stone Weight.java	
+++ b/Easy/Last Stone Weight.java	
@@ -1,16 +1,16 @@
 class Solution {
   public int lastStoneWeight(int[] stones) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+    PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> o2 - o1);
     for (int stone : stones) {
       pq.add(stone);
     }
     while (pq.size() > 1) {
-      int max1 = pq.poll();
-      int max2 = pq.poll();
-      if (max1 != max2) {
-        pq.add(max1 - max2);
+      int firstStone = pq.poll();
+      int secondStone = pq.poll();
+      if (firstStone != secondStone) {
+        pq.add(firstStone - secondStone);
       }
     }
-    return pq.isEmpty() ? 0 : pq.peek();
+    return pq.isEmpty() ? 0 : pq.poll();
   }
 }

From 27848c9eb57e4fae3c199632ca19a188dc4eaa0a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Apr 2022 12:11:23 +0530
Subject: [PATCH 0930/2175] Create Continuous Subarray Sum.java

---
 Medium/Continuous Subarray Sum.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Continuous Subarray Sum.java

diff --git a/Medium/Continuous Subarray Sum.java b/Medium/Continuous Subarray Sum.java
new file mode 100644
index 00000000..267857ab
--- /dev/null
+++ b/Medium/Continuous Subarray Sum.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public boolean checkSubarraySum(int[] nums, int k) {
+    Map<Integer, Integer> map = new HashMap<>();
+    map.put(0, -1);
+    int currSum = 0;
+    for (int i = 0; i < nums.length; i++) {
+      currSum += nums[i];
+      int rem = currSum % k;
+      if (map.containsKey(rem)) {
+        if (i - map.get(rem) >= 2) {
+          return true;
+        }
+      } else {
+        map.put(rem, i);
+      }
+    }
+    return false;
+  }
+}

From 04c96f86a5854b5443d8b5449bc3b4c7d3097628 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Apr 2022 19:56:46 +0530
Subject: [PATCH 0931/2175] Update Find All Possible Recipes from Given
 Supplies.java

---
 ... Possible Recipes from Given Supplies.java | 37 +++++++++----------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/Medium/Find All Possible Recipes from Given Supplies.java b/Medium/Find All Possible Recipes from Given Supplies.java
index bf0e2976..702d1d15 100644
--- a/Medium/Find All Possible Recipes from Given Supplies.java	
+++ b/Medium/Find All Possible Recipes from Given Supplies.java	
@@ -1,30 +1,29 @@
 class Solution {
-  public List<String> findAllRecipes(String[] recipes, List<List<String>> ingredients,
-      String[] supplies) {
-    Map<String, Set<String>> ingredientToRecipeMap = new HashMap<>();
-    Map<String, Integer> recipeToIngredientCount = new HashMap<>();
+  public List<String> findAllRecipes(String[] recipes, List<List<String>> ingredients, String[] supplies) {
+    Map<String, List<String>> map = new HashMap<>();
+    Map<String, Integer> ingredientCounter = new HashMap<>();
     for (int i = 0; i < recipes.length; i++) {
-      String recipe = recipes[i];
-      List<String> ingredientsForRecipe = ingredients.get(i);
-      recipeToIngredientCount.put(recipe, ingredientsForRecipe.size());
-      for (String ingredient : ingredientsForRecipe) {
-        ingredientToRecipeMap.computeIfAbsent(ingredient, k -> new HashSet<>()).add(recipe);
+      List<String> currentIngredientList = ingredients.get(i);
+      for (String ingredient : currentIngredientList) {
+        map.computeIfAbsent(ingredient, k -> new ArrayList<>()).add(recipes[i]);
+        ingredientCounter.put(recipes[i], ingredientCounter.getOrDefault(recipes[i], 0) + 1);
       }
     }
-    Queue<String> queue = new LinkedList<>(List.of(supplies));
-    Set<String> result = new HashSet<>();
+    Queue<String> queue = new LinkedList<>();
+    Set<String> prepared = new HashSet<>();
+    for (String supply : supplies) {
+      queue.add(supply);
+    }
     while (!queue.isEmpty()) {
-      String ingredient = queue.remove();
-      for (String dependentRecipe : ingredientToRecipeMap.getOrDefault(ingredient,
-          new HashSet<>())) {
-        recipeToIngredientCount.put(dependentRecipe,
-            recipeToIngredientCount.get(dependentRecipe) - 1);
-        if (recipeToIngredientCount.get(dependentRecipe) == 0) {
-          result.add(dependentRecipe);
+      String removed = queue.remove();
+      for (String dependentRecipe : map.getOrDefault(removed, new ArrayList<>())) {
+        ingredientCounter.put(dependentRecipe, ingredientCounter.getOrDefault(dependentRecipe, 0) - 1);
+        if (ingredientCounter.get(dependentRecipe) == 0) {
           queue.add(dependentRecipe);
+          prepared.add(dependentRecipe);
         }
       }
     }
-    return new ArrayList<>(result);
+    return new ArrayList<>(prepared);
   }
 }

From d1d2dc1349dd995a04fd2704f44645488885c5f1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 12 Apr 2022 11:23:38 +0530
Subject: [PATCH 0932/2175] Create Largest Number After Digit Swaps by
 Parity.java

---
 ...st Number After Digit Swaps by Parity.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Easy/Largest Number After Digit Swaps by Parity.java

diff --git a/Easy/Largest Number After Digit Swaps by Parity.java b/Easy/Largest Number After Digit Swaps by Parity.java
new file mode 100644
index 00000000..1959ca40
--- /dev/null
+++ b/Easy/Largest Number After Digit Swaps by Parity.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public int largestInteger(int num) {
+    char[] digits = String.valueOf(num).toCharArray();
+    int[] frequency = new int[10];
+    for (int i = 0; i < digits.length; i++) {
+      frequency[digits[i] - '0']++;
+    }
+    int largestNumber = 0;
+    int evenIdx = 8;
+    int oddIdx = 9;
+    for (int i = 0; i < digits.length; i++) {
+      if (digits[i] % 2 == 0) {
+        while (frequency[evenIdx] == 0) {
+          evenIdx -= 2;
+        }
+        frequency[evenIdx]--;
+        largestNumber = largestNumber * 10 + evenIdx;
+      } else {
+        while (frequency[oddIdx] == 0) {
+          oddIdx -= 2;
+        }
+        frequency[oddIdx]--;
+        largestNumber = largestNumber * 10 + oddIdx;
+      }
+    }
+    return largestNumber;
+  }
+}

From 4b69e8682ebc037db4f74ac3324eea9098da5580 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Apr 2022 13:30:06 +0530
Subject: [PATCH 0933/2175] Update Kth Largest Element in a Stream.java

---
 Easy/Kth Largest Element in a Stream.java | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/Easy/Kth Largest Element in a Stream.java b/Easy/Kth Largest Element in a Stream.java
index e3ab89a0..30bbc6f6 100644
--- a/Easy/Kth Largest Element in a Stream.java	
+++ b/Easy/Kth Largest Element in a Stream.java	
@@ -1,21 +1,22 @@
 class KthLargest {
-  PriorityQueue<Integer> pq;
-  int k;
+
+  private PriorityQueue<Integer> pq;
+  private int k;
   public KthLargest(int k, int[] nums) {
-    pq = new PriorityQueue<>();
     this.k = k;
+    this.pq = new PriorityQueue<>();
     for (int num : nums) {
-      add(num);
+      pq.add(num);
+      if (pq.size() > k) {
+        pq.poll();
+      }
     }
   }
 
-  public int add(int num) {
-    if (pq.size() < k) {
-      pq.add(num);
-    }
-    else if (pq.peek() < num) {
+  public int add(int val) {
+    pq.add(val);
+    if (pq.size() > k) {
       pq.poll();
-      pq.add(num);
     }
     return pq.peek();
   }

From ff59c63575cffa067ea4c78d3087be04d7f816dd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Apr 2022 13:38:06 +0530
Subject: [PATCH 0934/2175] Update Baseball Game.java

---
 Easy/Baseball Game.java | 33 +++++++++++++++------------------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/Easy/Baseball Game.java b/Easy/Baseball Game.java
index eb499246..87e2eea4 100644
--- a/Easy/Baseball Game.java	
+++ b/Easy/Baseball Game.java	
@@ -1,28 +1,25 @@
 class Solution {
   public int calPoints(String[] ops) {
     Stack<Integer> stack = new Stack<>();
-    int sum = 0;
+    int totalScore = 0;
     for (String op : ops) {
-      if (op.equals("+")) {
-        int prev = stack.pop();
-        int prevToPrev = stack.peek();
-        int newScore = prev + prevToPrev;
-        sum += newScore;
-        stack.push(prev);
+      if (op.equals("D")) {
+        int newScore = 2 * stack.peek();
+        totalScore += newScore;
         stack.push(newScore);
-      }
-      else if (op.equals("C")) {
-        sum -= stack.pop();
-      }
-      else if (op.equals("D")) {
-        sum += stack.peek() * 2;
-        stack.push(stack.peek() * 2);
-      }
-      else {
+      } else if (op.equals("C")) {
+        totalScore -= stack.pop();
+      } else if (op.equals("+")) {
+        int scoreTwo = stack.pop();
+        int newScore = scoreTwo + stack.peek();
+        stack.push(scoreTwo);
+        stack.push(newScore);
+        totalScore += newScore;
+      } else {
         stack.push(Integer.parseInt(op));
-        sum += stack.peek();
+        totalScore += Integer.parseInt(op);
       }
     }
-    return sum;
+    return totalScore;
   }
 }

From 4766ba505d22243e9c04a6eb0bf32cfe7bc23c0a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Apr 2022 06:43:08 +0530
Subject: [PATCH 0935/2175] Update Search in a Binary Search Tree.java

---
 Easy/Search in a Binary Search Tree.java | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/Easy/Search in a Binary Search Tree.java b/Easy/Search in a Binary Search Tree.java
index caed08fe..63e2f736 100644
--- a/Easy/Search in a Binary Search Tree.java	
+++ b/Easy/Search in a Binary Search Tree.java	
@@ -16,16 +16,11 @@
 class Solution {
   public TreeNode searchBST(TreeNode root, int val) {
     if (root == null) {
-      return null;
+      return root;
     }
     if (root.val == val) {
       return root;
     }
-    else if (root.val > val) {
-      return searchBST(root.left, val);
-    }
-    else {
-      return searchBST(root.right, val);
-    }
+    return root.val > val ? searchBST(root.left, val) : searchBST(root.right, val);
   }
 }

From cf74591dd18d24ab86a118baff87f27a032f8c69 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Apr 2022 07:28:54 +0530
Subject: [PATCH 0936/2175] Create Minimize Product Sum of Two Arrays.java

---
 .../Minimize Product Sum of Two Arrays.java   | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Minimize Product Sum of Two Arrays.java

diff --git a/Medium/Minimize Product Sum of Two Arrays.java b/Medium/Minimize Product Sum of Two Arrays.java
new file mode 100644
index 00000000..4f8e184b
--- /dev/null
+++ b/Medium/Minimize Product Sum of Two Arrays.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int minProductSum(int[] nums1, int[] nums2) {
+    int[] frequencyOne = new int[101];
+    int[] frequencyTwo = new int[101];
+    for (int i = 0; i < nums1.length; i++) {
+      frequencyOne[nums1[i]]++;
+      frequencyTwo[nums2[i]]++;
+    }
+    int idxOne = 0;
+    int idxTwo = 100;
+    int sum = 0;
+    while (idxOne < 101 && idxTwo >= 0) {
+      while (idxOne < 101 && frequencyOne[idxOne] == 0) {
+        idxOne++;
+      }
+      while (idxTwo >= 0 && frequencyTwo[idxTwo] == 0) {
+        idxTwo--;
+      }
+      if (idxOne == 101 || idxTwo == -1) {
+        break;
+      }
+      int counter = Math.min(frequencyOne[idxOne], frequencyTwo[idxTwo]);
+      sum += counter * idxOne * idxTwo;
+      frequencyOne[idxOne] -= counter;
+      frequencyTwo[idxTwo] -= counter;
+    }
+    return sum;
+  }   
+}

From e9f848ca47be5da788ffc030ca2531a511232749 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Apr 2022 06:49:00 +0530
Subject: [PATCH 0937/2175] Update Increasing Order Search Tree.java

---
 Easy/Increasing Order Search Tree.java | 34 ++++++++++++++------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/Easy/Increasing Order Search Tree.java b/Easy/Increasing Order Search Tree.java
index 93e003f3..1ca57c9b 100644
--- a/Easy/Increasing Order Search Tree.java	
+++ b/Easy/Increasing Order Search Tree.java	
@@ -14,22 +14,26 @@
  * }
  */
 class Solution {
-  TreeNode curr;
   public TreeNode increasingBST(TreeNode root) {
-    TreeNode ans = new TreeNode(-1);
-    curr = ans;
-    inorder(root);
-    return ans.right;
-  }
-  
-  private void inorder(TreeNode node) {
-    if (node == null) {
-      return;
+    Stack<TreeNode> stack = new Stack<>();
+    while (root != null) {
+      stack.push(root);
+      root = root.left;
+    }
+    TreeNode newHead = null;
+    while (!stack.isEmpty()) {
+      TreeNode removed = stack.pop();
+      if (newHead == null) {
+        newHead = removed;
+      }
+      TreeNode rightNode = removed.right;
+      while (rightNode != null) {
+        stack.push(rightNode);
+        rightNode = rightNode.left;
+      }
+      removed.right = stack.isEmpty() ? null : stack.peek();
+      removed.left = null;
     }
-    inorder(node.left);
-    node.left = null;
-    curr.right = node;
-    curr = node;
-    inorder(node.right);
+    return newHead;
   }
 }

From d90fea8e6157d3a0063830059b71d025a93d6599 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Apr 2022 06:53:35 +0530
Subject: [PATCH 0938/2175] Create Find Closest Number to Zero.java

---
 Easy/Find Closest Number to Zero.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Find Closest Number to Zero.java

diff --git a/Easy/Find Closest Number to Zero.java b/Easy/Find Closest Number to Zero.java
new file mode 100644
index 00000000..ecb13d9f
--- /dev/null
+++ b/Easy/Find Closest Number to Zero.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int findClosestNumber(int[] nums) {
+    int[] result = {Integer.MAX_VALUE, Integer.MIN_VALUE};
+    for (int num : nums) {
+      int distance = Math.abs(num);
+      if (distance <= result[0]) {
+        if (distance < result[0]) {
+          result[0] = distance;
+          result[1] = num;
+        } else {
+          result[1] = Math.max(num, result[1]);
+        }
+      }
+    }
+    return result[1];
+  }
+}

From 012db7fa382f390fab5e9b641f29cc9f2a74cb2a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Apr 2022 07:12:17 +0530
Subject: [PATCH 0939/2175] Create Design an ATM Machine.java

---
 Medium/Design an ATM Machine.java | 43 +++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 Medium/Design an ATM Machine.java

diff --git a/Medium/Design an ATM Machine.java b/Medium/Design an ATM Machine.java
new file mode 100644
index 00000000..b4888a7a
--- /dev/null
+++ b/Medium/Design an ATM Machine.java	
@@ -0,0 +1,43 @@
+class ATM {
+
+  private long[] noteCount;
+  private int[] noteValue;
+
+  public ATM() {
+    this.noteCount = new long[5];
+    this.noteValue = new int[]{20, 50, 100, 200, 500};
+  }
+
+  public void deposit(int[] banknotesCount) {
+    for (int i = 0; i < banknotesCount.length; i++) {
+      this.noteCount[i] += banknotesCount[i];
+    }
+  }
+
+  public int[] withdraw(int amount) {
+    int[] resultNoteCount = new int[5];
+    for (int i = this.noteValue.length - 1; i >= 0 && amount > 0; i--) {
+      if (amount >= this.noteValue[i]) {
+        long numOfNotes = Math.min(amount / this.noteValue[i], this.noteCount[i]);
+        amount -= this.noteValue[i] * numOfNotes;
+        resultNoteCount[i] = (int) numOfNotes;
+      }
+    }
+    if (amount > 0) {
+      return new int[]{-1};
+    }
+    if (amount == 0) {
+      for (int i = 0; i < resultNoteCount.length; i++) {
+        this.noteCount[i] -= resultNoteCount[i];
+      }
+    }
+    return resultNoteCount;
+  }
+}
+
+/**
+ * Your ATM object will be instantiated and called as such:
+ * ATM obj = new ATM();
+ * obj.deposit(banknotesCount);
+ * int[] param_2 = obj.withdraw(amount);
+ */

From 1b21e540176e4eade110a8640350b630660915dc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Apr 2022 11:38:19 +0530
Subject: [PATCH 0940/2175] Create Calculate Digit Sum of a String.java

---
 Easy/Calculate Digit Sum of a String.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Calculate Digit Sum of a String.java

diff --git a/Easy/Calculate Digit Sum of a String.java b/Easy/Calculate Digit Sum of a String.java
new file mode 100644
index 00000000..cf5e9bad
--- /dev/null
+++ b/Easy/Calculate Digit Sum of a String.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public String digitSum(String s, int k) {
+    while (s.length() > k) {
+      s = formDigitSum(s, k);
+    }
+    return s;
+  }
+  
+  private String formDigitSum(String s, int k) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < s.length(); i += k) {
+      int currSum = 0;
+      for (int j = i; j < Math.min(i + k, s.length()); j++) {
+        currSum += Character.getNumericValue(s.charAt(j));
+      }
+      sb.append(currSum);
+    }
+    return sb.toString();
+  }
+}

From 12c415e5b0be31301607a66815e3ad71e7c3da3d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 19 Apr 2022 09:35:01 +0530
Subject: [PATCH 0941/2175] Create Recover Binary Search Tree.java

---
 Medium/Recover Binary Search Tree.java | 43 ++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 Medium/Recover Binary Search Tree.java

diff --git a/Medium/Recover Binary Search Tree.java b/Medium/Recover Binary Search Tree.java
new file mode 100644
index 00000000..8a3a133f
--- /dev/null
+++ b/Medium/Recover Binary Search Tree.java	
@@ -0,0 +1,43 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public void recoverTree(TreeNode root) {
+    TreeNode nodeOne = null;
+    TreeNode nodeTwo = null;
+    TreeNode prevNode = null;
+    Stack<TreeNode> stack = new Stack<>();
+    while (root != null || !stack.isEmpty()) {
+      while (root != null) {
+        stack.push(root);
+        root = root.left;
+      }
+      if (!stack.isEmpty()) {
+        root = stack.pop();
+        if (nodeOne == null && prevNode != null && prevNode.val > root.val) {
+          nodeOne = prevNode;
+        }
+        if (nodeOne != null && prevNode.val > root.val) {
+          nodeTwo = root;
+        }
+        prevNode = root;
+        root = root.right;
+      }
+    }
+    int tempValue = nodeOne.val;
+    nodeOne.val = nodeTwo.val;
+    nodeTwo.val = tempValue;
+  }
+}

From 8cbbc26e563acde7a4fd7867309069f6c28295ee Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Apr 2022 08:55:42 +0530
Subject: [PATCH 0942/2175] Update Binary Search Tree Iterator.java

---
 Medium/Binary Search Tree Iterator.java | 28 +++++++++++++------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/Medium/Binary Search Tree Iterator.java b/Medium/Binary Search Tree Iterator.java
index 28e6aaa4..01b26971 100644
--- a/Medium/Binary Search Tree Iterator.java	
+++ b/Medium/Binary Search Tree Iterator.java	
@@ -14,27 +14,29 @@
  * }
  */
 class BSTIterator {
-  Stack<TreeNode> stack;
+  
+  private Stack<TreeNode> stack;
+  
   public BSTIterator(TreeNode root) {
-    stack = new Stack<>();
-    while (root != null) {
-      stack.push(root);
-      root = root.left;
-    }
+    this.stack = new Stack<>();
+    updateStack(root);
   }
 
   public int next() {
-    TreeNode node = stack.pop();
-    TreeNode rightNode = node.right;
-    while (rightNode != null) {
-      stack.push(rightNode);
-      rightNode = rightNode.left;
-    }
+    TreeNode node = this.stack.pop();
+    updateStack(node.right);
     return node.val;
   }
 
   public boolean hasNext() {
-    return !stack.isEmpty();
+    return !this.stack.isEmpty();
+  }
+  
+  private void updateStack(TreeNode node) {
+    while (node != null) {
+      this.stack.push(node);
+      node = node.left;
+    }
   }
 }
 

From 173b8bce6b72da0e1e4b672ab11b037b59deee12 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Apr 2022 12:44:21 +0530
Subject: [PATCH 0943/2175] Create Binary Search Tree Iterator II.java

---
 Medium/Binary Search Tree Iterator II.java | 69 ++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 Medium/Binary Search Tree Iterator II.java

diff --git a/Medium/Binary Search Tree Iterator II.java b/Medium/Binary Search Tree Iterator II.java
new file mode 100644
index 00000000..9f98110c
--- /dev/null
+++ b/Medium/Binary Search Tree Iterator II.java	
@@ -0,0 +1,69 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class BSTIterator {
+  
+  private Deque<TreeNode> stack;
+  private List<Integer> arr;
+  private TreeNode lastNode;
+  private int pointer;
+  
+  public BSTIterator(TreeNode root) {
+    this.stack = new ArrayDeque();
+    this.arr = new ArrayList<>();
+    this.lastNode = root;
+    this.pointer = -1;
+  }
+
+  public boolean hasNext() {
+    return !this.stack.isEmpty() || lastNode != null || this.pointer < arr.size() - 1;
+  }
+
+  public int next() {
+    this.pointer++;
+    if (this.pointer == this.arr.size()) {
+      updateStack(lastNode);
+      TreeNode curr = this.stack.pop();
+      lastNode = curr.right;
+      this.arr.add(curr.val);
+    }
+    return this.arr.get(this.pointer);
+  }
+
+  public boolean hasPrev() {
+    return this.pointer > 0;
+  }
+
+  public int prev() {
+    this.pointer--;
+    return this.arr.get(this.pointer);
+  }
+  
+  private void updateStack(TreeNode node) {
+    while (node != null) {
+      this.stack.push(node);
+      node = node.left;
+    }
+  }
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * BSTIterator obj = new BSTIterator(root);
+ * boolean param_1 = obj.hasNext();
+ * int param_2 = obj.next();
+ * boolean param_3 = obj.hasPrev();
+ * int param_4 = obj.prev();
+ */

From 4b673d8a010bc3e12352b5013a64741ca069601a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 21 Apr 2022 18:55:32 +0530
Subject: [PATCH 0944/2175] Rename Easy/Max Area of Island.java to Medium/Max
 Area of Island.java

---
 {Easy => Medium}/Max Area of Island.java | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {Easy => Medium}/Max Area of Island.java (100%)

diff --git a/Easy/Max Area of Island.java b/Medium/Max Area of Island.java
similarity index 100%
rename from Easy/Max Area of Island.java
rename to Medium/Max Area of Island.java

From a5f5817540d69c471a563050d5c50d5cd2a7552a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 21 Apr 2022 19:14:26 +0530
Subject: [PATCH 0945/2175] Update Number of Closed Islands.java

---
 Medium/Number of Closed Islands.java | 50 ++++++++++++++++------------
 1 file changed, 29 insertions(+), 21 deletions(-)

diff --git a/Medium/Number of Closed Islands.java b/Medium/Number of Closed Islands.java
index e55843c5..201b30a3 100644
--- a/Medium/Number of Closed Islands.java	
+++ b/Medium/Number of Closed Islands.java	
@@ -2,31 +2,39 @@ class Solution {
   private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
   
   public int closedIsland(int[][] grid) {
-    int numberOfClosedIslands = 0;
-    for(int i = 0; i < grid.length; i++){
-      for(int j = 0; j < grid[0].length; j++){
-        if(grid[i][j] == 0){
-          if(surroundsSuccessfully(grid, i, j)) {
-            numberOfClosedIslands++;
-          }
+    int closedIslandCount = 0;
+    for (int i = 0; i < grid.length; i++) {
+      for (int j = 0; j < grid[0].length; j++) {
+        if (grid[i][j] == 0 && isSurroundedSuccessfully(grid, i, j)) {
+          closedIslandCount++;
         }
       }
     }
-    return numberOfClosedIslands;
+    return closedIslandCount;
   }
-
-  private boolean surroundsSuccessfully(int[][] grid, int x, int y) {
-    if(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length) {
-      return false;
-    }
-    if(grid[x][y] == 1) {
-      return true;
-    }
-    grid[x][y] = 1;
-    boolean result = true;
-    for(int[] dir : DIRS){
-      result = result & surroundsSuccessfully(grid, x + dir[0], y + dir[1]);
+  
+  private boolean isSurroundedSuccessfully(int[][] grid, int i, int j) {
+    Queue<int[]> queue = new LinkedList<>();
+    queue.add(new int[]{i, j});
+    boolean surroundingCheck = true;
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int x = removed[0];
+      int y = removed[1];
+      if (x < 0 || y < 0 || x >= grid.length || y >= grid[0].length) {
+        surroundingCheck = false;
+        continue;
+      }
+      if (grid[x][y] == 1) {
+        continue;
+      }
+      grid[x][y] = 1;
+      for (int[] dir : DIRS) {
+        int newX = x + dir[0];
+        int newY = y + dir[1];
+        queue.add(new int[]{newX, newY});
+      }
     }
-    return result;
+    return surroundingCheck;
   }
 }

From 60cdab24eb68678944f0610b02c18ba0c92466a1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 21 Apr 2022 21:22:14 +0530
Subject: [PATCH 0946/2175] Update Next Permutation.java

---
 Medium/Next Permutation.java | 47 +++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 25 deletions(-)

diff --git a/Medium/Next Permutation.java b/Medium/Next Permutation.java
index a29876cb..9b554900 100644
--- a/Medium/Next Permutation.java	
+++ b/Medium/Next Permutation.java	
@@ -1,32 +1,29 @@
 class Solution {
   public void nextPermutation(int[] nums) {
-    boolean flag = true;
-    int right = nums.length - 1;
-    int start = right;
-    while (start >= 1) {
-      if (nums[start] > nums[start - 1]) {
-        int idx = right;
-        while (nums[idx] <= nums[start - 1]) {
-          idx--;
-        }
-        int temp = nums[start - 1];
-        nums[start - 1] = nums[idx];
-        nums[idx] = temp;
-        flag = false;
-        break;
-      }
-      start--;
-    }
-    if (flag) {
-      Arrays.sort(nums);
+    if (nums.length <= 1) {
       return;
     }
-    while (start < right) {
-      int temp = nums[start];
-      nums[start] = nums[right];
-      nums[right] = temp;
-      start++;
-      right--;
+    int idx = nums.length - 2;
+    while (idx >= 0 && nums[idx] >= nums[idx + 1]) {
+      idx--;
+    }
+    if (idx >= 0) {
+      int endIdx = nums.length - 1;
+      while (nums[endIdx] <= nums[idx]) {
+        endIdx--;
+      }
+      swap(nums, idx, endIdx);
+    }
+    int startIdx = idx + 1;
+    int endIdx = nums.length - 1;
+    while (startIdx < endIdx) {
+      swap(nums, startIdx++, endIdx--);
     }
   }
+  
+  private void swap(int[] nums, int idxOne, int idxTwo) {
+    int temp = nums[idxOne];
+    nums[idxOne] = nums[idxTwo];
+    nums[idxTwo] = temp;
+  }
 }

From 12cbf33169435f81428a201ab099e31b69da990e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 24 Apr 2022 02:03:51 -0700
Subject: [PATCH 0947/2175] Create Intersection of Multiple Arrays.java

---
 Easy/Intersection of Multiple Arrays.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Intersection of Multiple Arrays.java

diff --git a/Easy/Intersection of Multiple Arrays.java b/Easy/Intersection of Multiple Arrays.java
new file mode 100644
index 00000000..f06c30b8
--- /dev/null
+++ b/Easy/Intersection of Multiple Arrays.java	
@@ -0,0 +1,19 @@
+import java.util.Map.Entry;
+
+
+class Solution {
+  public List<Integer> intersection(int[][] nums) {
+    Map<Integer, Integer> counter = new HashMap<>();
+    for (int[] num : nums) {
+      for (int element : num) {
+        counter.put(element, counter.getOrDefault(element, 0) + 1);
+      }
+    }
+    return counter.entrySet()
+      .stream()
+      .filter(entry -> entry.getValue() == nums.length)
+      .map(Entry::getKey)
+      .sorted()
+      .collect(Collectors.toList());
+  }
+}

From f937b5a0e18554a77858dd3db97211a637d09995 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 24 Apr 2022 16:35:51 -0700
Subject: [PATCH 0948/2175] Update Asteroid Collision.java

---
 Medium/Asteroid Collision.java | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/Medium/Asteroid Collision.java b/Medium/Asteroid Collision.java
index 102f3f53..f739ff48 100644
--- a/Medium/Asteroid Collision.java	
+++ b/Medium/Asteroid Collision.java	
@@ -10,19 +10,17 @@ public int[] asteroidCollision(int[] asteroids) {
           if (stack.peek() == Math.abs(asteroid)) {
             stack.pop();
           }
-        }
-        else {
+        } else {
           stack.push(asteroid);
         }
-      }
-      else {
+      } else {
         stack.push(asteroid);
       }
     }
-    int[] state = new int[stack.size()];
-    for (int i = state.length - 1; i >= 0; i--) {
-      state[i] = stack.pop();
+    int[] result = new int[stack.size()];
+    for (int i = result.length - 1; i >= 0; i--) {
+      result[i] = stack.pop();
     }
-    return state;
+    return result;
   }
 }

From ca2f90813f6c01fa90cac0d40e5d03bfbb1b298d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 24 Apr 2022 18:00:51 -0700
Subject: [PATCH 0949/2175] Update Peeking Iterator.java

---
 Medium/Peeking Iterator.java | 47 ++++++++++++++++++------------------
 1 file changed, 24 insertions(+), 23 deletions(-)

diff --git a/Medium/Peeking Iterator.java b/Medium/Peeking Iterator.java
index 63ab64cb..4a1c6782 100644
--- a/Medium/Peeking Iterator.java	
+++ b/Medium/Peeking Iterator.java	
@@ -2,34 +2,35 @@
 // https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html
 
 class PeekingIterator implements Iterator<Integer> {
-  Integer nextElement;
-  Iterator<Integer> iterator;
+  private Iterator<Integer> iterator;
+  private Integer topElement;
+
   public PeekingIterator(Iterator<Integer> iterator) {
     // initialize any member here.
     this.iterator = iterator;
-    updateNext();
-  }
-  
-  private void updateNext() {
-    nextElement = iterator.hasNext() ? iterator.next() : null;
+    populateTopElement();
   }
-	
+
   // Returns the next element in the iteration without advancing the iterator.
   public Integer peek() {
-    return nextElement;
+    return this.topElement;
+  }
+
+  // hasNext() and next() should behave the same as in the Iterator interface.
+  // Override them if needed.
+  @Override
+  public Integer next() {
+    Integer nextValue = this.topElement;
+    populateTopElement();
+    return nextValue;
+  }
+
+  @Override
+  public boolean hasNext() {
+    return this.topElement != null;
+  }
+
+  private void populateTopElement() {
+    this.topElement = this.iterator.hasNext() ? this.iterator.next() : null;
   }
-	
-	// hasNext() and next() should behave the same as in the Iterator interface.
-	// Override them if needed.
-	@Override
-	public Integer next() {
-    Integer returnValue = nextElement;
-    updateNext();
-    return returnValue;
-	}
-	
-	@Override
-	public boolean hasNext() {
-	  return nextElement != null;
-	}
 }

From 1c4f6a504fd9962be7f0c85bd366cd57d909c118 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Apr 2022 09:42:06 -0700
Subject: [PATCH 0950/2175] Create Count Sub Islands.java

---
 Medium/Count Sub Islands.java | 42 +++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Count Sub Islands.java

diff --git a/Medium/Count Sub Islands.java b/Medium/Count Sub Islands.java
new file mode 100644
index 00000000..adee5af9
--- /dev/null
+++ b/Medium/Count Sub Islands.java	
@@ -0,0 +1,42 @@
+class Solution {
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
+  public int countSubIslands(int[][] grid1, int[][] grid2) {
+    int numRows = grid1.length;
+    int numCols = grid1[0].length;
+    int subIslandCount = 0;
+    boolean[][] visited = new boolean[numRows][numCols];
+    for (int i = 0; i < numRows; i++) {
+      for (int j = 0; j < numCols; j++) {
+        if (!visited[i][j] && grid2[i][j] == 1) {
+          Queue<int[]> queue = new LinkedList<>();
+          queue.add(new int[]{i, j});
+          boolean isSubisland = true;
+          while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int x = removed[0];
+            int y = removed[1];
+            if (visited[x][y]) {
+              continue;
+            }
+            if (grid1[x][y] != 1) {
+              isSubisland = false;
+            }
+            visited[x][y] = true;
+            for (int[] dir : DIRS) {
+              int newX = x + dir[0];
+              int newY = y + dir[1];
+              if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && !visited[newX][newY] && grid2[newX][newY] == 1) {
+                queue.add(new int[]{newX, newY});
+              }
+            }
+          }
+          if (isSubisland) {
+            subIslandCount++;
+          }
+        }
+      }
+    }
+    return subIslandCount;
+  }
+}

From 1b1755b0297415fcd71eadd8d5f7dfb1ad60f6c7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Apr 2022 12:08:55 -0700
Subject: [PATCH 0951/2175] Update As Far from Land as Possible.java

---
 Medium/As Far from Land as Possible.java | 63 ++++++++++++------------
 1 file changed, 32 insertions(+), 31 deletions(-)

diff --git a/Medium/As Far from Land as Possible.java b/Medium/As Far from Land as Possible.java
index 2096777d..2e80a70b 100644
--- a/Medium/As Far from Land as Possible.java	
+++ b/Medium/As Far from Land as Possible.java	
@@ -1,36 +1,37 @@
 class Solution {
-    public int maxDistance(int[][] grid) {
-        if (grid.length == 0 || grid[0].length == 0) {
-            return -1;
+  private final int[][] DIRS = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
+  
+  public int maxDistance(int[][] grid) {
+    Queue<int[]> queue = new LinkedList<>();
+    int numRows = grid.length;
+    int numCols = grid[0].length;
+    for (int i = 0; i < numRows; i++) {
+      for (int j = 0; j < numCols; j++) {
+        if (grid[i][j] == 1) {
+          queue.add(new int[]{i, j});
         }
-        int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-        boolean[][] visited = new boolean[grid.length][grid[0].length];
-        Queue<int[]> queue = new LinkedList<>();
-        for (int i = 0; i < grid.length; i++) {
-            for (int j = 0; j < grid[0].length; j++) {
-                if (grid[i][j] == 1) {
-                    queue.add(new int[]{i, j});
-                    visited[i][j] = true;
-                }
-            }
-        }
-        int maxDist = -1;
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            while (size-- > 0) {
-                int[] curr = queue.remove();
-                for (int[] dir : dirs) {
-                    int x = curr[0] + dir[0];
-                    int y = curr[1] + dir[1];
-                    if (x >= 0 &&  x < grid.length && y >= 0 && y < grid[0].length && !visited[x][y] && grid[x][y] == 0) {
-                        visited[x][y] = true;
-                        queue.add(new int[]{x, y});
-                    }
-                }
-            }
-            maxDist++;
+      }
+    }
+    if (queue.isEmpty() || queue.size() == numRows * numCols) {
+      return -1;
+    }
+    int distance = 0;
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int[] removed = queue.remove();
+        for (int[] dir : DIRS) {
+          int x = removed[0] + dir[0];
+          int y = removed[1] + dir[1];
+          if (x < 0 || y < 0 || x >= numRows || y >= numCols || grid[x][y] == 1) {
+            continue;
+          }
+          grid[x][y] = 1;
+          queue.add(new int[]{x, y});
         }
-
-        return maxDist == 0 ? -1 : maxDist;
+      }
+      distance++;
     }
+    return distance - 1; 
+  }
 }

From 7deaabf0c2ad2172ec38d09c1b2f18b57d89af32 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 27 Apr 2022 13:32:24 -0700
Subject: [PATCH 0952/2175] Create Pacific Atlantic Water Flow.java

---
 Medium/Pacific Atlantic Water Flow.java | 52 +++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 Medium/Pacific Atlantic Water Flow.java

diff --git a/Medium/Pacific Atlantic Water Flow.java b/Medium/Pacific Atlantic Water Flow.java
new file mode 100644
index 00000000..3c129529
--- /dev/null
+++ b/Medium/Pacific Atlantic Water Flow.java	
@@ -0,0 +1,52 @@
+class Solution {
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
+  public List<List<Integer>> pacificAtlantic(int[][] heights) {
+    int numRows = heights.length;
+    int numCols = heights[0].length;
+    Queue<int[]> pacificQueue = new LinkedList<>();
+    Queue<int[]> atlanticQueue = new LinkedList<>();
+    for (int i = 0; i < numRows; i++) {
+      pacificQueue.add(new int[]{i, 0});
+      atlanticQueue.add(new int[]{i, numCols - 1});
+    }
+    for (int i = 0; i < numCols; i++) {
+      pacificQueue.add(new int[]{0, i});
+      atlanticQueue.add(new int[]{numRows - 1, i});
+    }
+    boolean[][] pacificReachable = bfs(pacificQueue, heights);
+    boolean[][] atlanticReachable = bfs(atlanticQueue, heights);
+    List<List<Integer>> result = new ArrayList<>();
+    for (int i = 0; i < numRows; i++) {
+      for (int j = 0; j < numCols; j++) {
+        if (pacificReachable[i][j] && atlanticReachable[i][j]) {
+          result.add(Arrays.asList(i, j));
+        }
+      }
+    }
+    return result;
+  }
+  
+  private boolean[][] bfs(Queue<int[]> queue, int[][] heights) {
+    int numRows = heights.length;
+    int numCols = heights[0].length;
+    boolean[][] reachable = new boolean[numRows][numCols];
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int x = removed[0];
+      int y = removed[1];
+      reachable[x][y] = true;
+      for (int[] dir : DIRS) {
+        int newX = x + dir[0];
+        int newY = y + dir[1];
+        if (newX < 0 || newY < 0 || newX >= numRows || newY >= numCols || reachable[newX][newY]) {
+          continue;
+        }
+        if (heights[newX][newY] >= heights[x][y]) {
+          queue.add(new int[]{newX, newY});
+        }
+      }
+    }
+    return reachable;
+  }
+}

From 859072dd3fd786f565b549e4319d2d7613a89749 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Apr 2022 07:42:27 -0700
Subject: [PATCH 0953/2175] Update Path With Minimum Effort.java

---
 Medium/Path With Minimum Effort.java | 65 ++++++++++++++++------------
 1 file changed, 37 insertions(+), 28 deletions(-)

diff --git a/Medium/Path With Minimum Effort.java b/Medium/Path With Minimum Effort.java
index 5d336e11..b9c33606 100644
--- a/Medium/Path With Minimum Effort.java	
+++ b/Medium/Path With Minimum Effort.java	
@@ -1,38 +1,47 @@
 class Solution {
+  
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
   public int minimumEffortPath(int[][] heights) {
-    int rows = heights.length;
-    int cols = heights[0].length;
-    int[][] directions = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
-    int[][] distance = new int[rows][cols];
-    for (int i = 0; i < rows; i++) {
-      Arrays.fill(distance[i], Integer.MAX_VALUE);
+    if (heights.length == 1 && heights[0].length == 1) {
+      return 0;
     }
-    PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
-    pq.add(new int[]{0, 0, 0});
-    while (!pq.isEmpty()) {
-      int[] removed = pq.poll();
-      int currDistance = removed[0];
-      int x = removed[1];
-      int y = removed[2];
-      if (currDistance > distance[x][y]) {
-        continue;
+    int leftBound = 0;
+    int rightBound = 1000000;
+    while (leftBound < rightBound) {
+      int mid = (leftBound + rightBound) / 2;
+      if (connected(heights, mid)) {
+        rightBound = mid;
+      } else {
+        leftBound = mid + 1;
       }
-      if (x == rows - 1 && y == cols - 1) {
-        return currDistance;
+    }
+    return leftBound;
+  }
+  
+  private boolean connected(int[][] heights, int targetEffort) {
+    int numRows = heights.length;
+    int numCols = heights[0].length;
+    Queue<int[]> queue = new LinkedList<>();
+    boolean[][] seen = new boolean[numRows][numCols];
+    queue.add(new int[]{0, 0});
+    seen[0][0] = true;
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int x = removed[0];
+      int y = removed[1];
+      if (x == numRows - 1 && y == numCols - 1) {
+        return true;
       }
-      for (int[] direction : directions) {
-        int newX = x + direction[0];
-        int newY = y + direction[1];
-        if (newX < 0 || newX >= rows || newY < 0 || newY >= cols) {
-          continue;
-        }
-        int newDistance = Math.max(currDistance, Math.abs(heights[newX][newY] - heights[x][y]));
-        if (distance[newX][newY] > newDistance) {
-          distance[newX][newY] = newDistance;
-          pq.add(new int[]{newDistance, newX, newY});
+      for (int[] dir : DIRS) {
+        int newX = x + dir[0];
+        int newY = y + dir[1];
+        if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && !seen[newX][newY] && Math.abs(heights[x][y] - heights[newX][newY]) <= targetEffort) {
+          queue.add(new int[]{newX, newY});
+          seen[newX][newY] = true;
         }
       }
     }
-    return -1;
+    return false;
   }
 }

From 8164bd64c51b9896e6bd99e492d61f85f6361d47 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Apr 2022 12:47:25 -0700
Subject: [PATCH 0954/2175] Update Shortest Path in Binary Matrix.java

---
 Medium/Shortest Path in Binary Matrix.java | 39 ++++++++++------------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/Medium/Shortest Path in Binary Matrix.java b/Medium/Shortest Path in Binary Matrix.java
index 0649b9b0..9977e11b 100644
--- a/Medium/Shortest Path in Binary Matrix.java	
+++ b/Medium/Shortest Path in Binary Matrix.java	
@@ -1,40 +1,37 @@
 class Solution {
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
+  
   public int shortestPathBinaryMatrix(int[][] grid) {
-    int n = grid.length;
-    if (n == 0 || grid[0][0] == 1 || grid[n - 1][n - 1] == 1) {
+    if (grid[0][0] == 1) {
       return -1;
     }
+    int numRows = grid.length;
+    int numCols = grid[0].length;
+    boolean[][] visited = new boolean[numRows][numCols];
     Queue<int[]> queue = new LinkedList<>();
-    int numberOfSteps = 0;
-    boolean[][] visited = new boolean[n][n];
-    queue.add(new int[] {0, 0});
+    queue.add(new int[]{0, 0});
     visited[0][0] = true;
+    int numOfSteps = 0;
     while (!queue.isEmpty()) {
+      numOfSteps++;
       int size = queue.size();
       while (size-- > 0) {
         int[] removed = queue.remove();
-        if (removed[0] == n - 1 && removed[1] == n - 1) {
-          return numberOfSteps + 1;
+        int x = removed[0];
+        int y = removed[1];
+        if (x == numRows - 1 && y == numCols - 1) {
+          return numOfSteps;
         }
-        for (int[] dir : EIGHT_DIRS) {
-          int newX = removed[0] + dir[0];
-          int newY = removed[1] + dir[1];
-          if (newX >= 0
-              && newX < n
-              && newY >= 0
-              && newY < n
-              && !visited[newX][newY]
-              && grid[newX][newY] == 0) {
-            queue.add(new int[] {newX, newY});
+        for (int[] dir : DIRS) {
+          int newX = x + dir[0];
+          int newY = y + dir[1];
+          if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && !visited[newX][newY] && grid[newX][newY] == 0) {
+            queue.add(new int[]{newX, newY});
             visited[newX][newY] = true;
           }
         }
       }
-      numberOfSteps++;
     }
     return -1;
   }
-
-  private static final int[][] EIGHT_DIRS = {
-    {0,1},{0,-1},{1,0},{-1,0},{1,-1},{-1,1},{-1,-1},{1,1}};
 }

From 6e3b0d0759917a906e3e292b32d4ae73d1299495 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Apr 2022 17:30:22 -0700
Subject: [PATCH 0955/2175] Update Is Graph Bipartite.java

---
 Medium/Is Graph Bipartite.java | 40 ++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/Medium/Is Graph Bipartite.java b/Medium/Is Graph Bipartite.java
index 23f4e0bf..c77018dc 100644
--- a/Medium/Is Graph Bipartite.java	
+++ b/Medium/Is Graph Bipartite.java	
@@ -4,23 +4,35 @@ public boolean isBipartite(int[][] graph) {
     int[] color = new int[n];
     Arrays.fill(color, -1);
     for (int i = 0; i < n; i++) {
-      if (color[i] == -1) {
-        Stack<Integer> stack = new Stack<>();
-        stack.push(i);
-        color[i] = 0;
-        while (!stack.isEmpty()) {
-          Integer node = stack.pop();
-          for (Integer neighbor : graph[node]) {
-            if (color[neighbor] == -1) {
-              stack.push(neighbor);
-              color[neighbor] = color[node] ^ 1;
-            }
-            else if (color[neighbor] == color[node]) {
-              return false;
-            }
+      if (color[i] == -1 && !bipartiteCheck(graph, i, color)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  private boolean bipartiteCheck(int[][] graph, int node, int[] color) {
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(node);
+    int currColor = 0;
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int removed = queue.remove();
+        if (color[removed] != -1) {
+          if (color[removed] != currColor) {
+            return false;
+          }
+          continue;
+        }
+        color[removed] = currColor;
+        for (int conn : graph[removed]) {
+          if (color[conn] == -1) {
+            queue.add(conn);
           }
         }
       }
+      currColor = currColor == 1 ? 0 : 1;
     }
     return true;
   }

From 5be1437bd2b37ef515fa1c72e973f179f1860481 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Apr 2022 18:15:03 -0700
Subject: [PATCH 0956/2175] Update Design Tic-Tac-Toe.java

---
 Medium/Design Tic-Tac-Toe.java | 84 ++++++++++++++--------------------
 1 file changed, 34 insertions(+), 50 deletions(-)

diff --git a/Medium/Design Tic-Tac-Toe.java b/Medium/Design Tic-Tac-Toe.java
index 35c3bd4b..50b57aea 100644
--- a/Medium/Design Tic-Tac-Toe.java	
+++ b/Medium/Design Tic-Tac-Toe.java	
@@ -1,66 +1,50 @@
 class TicTacToe {
 
-  /** Initialize your data structure here. */
-  int[][] board;
-  Map<Integer, Map<Integer, Integer>> rowMap;
-  Map<Integer, Map<Integer, Integer>> colMap;
-  Map<Integer, Integer> leftDiagonalMap;
-  Map<Integer, Integer> rightDiagonalMap;
-  int n;
+  private int n;
+  private Map<Integer, Map<Integer, Integer>> rowMapping;
+  private Map<Integer, Map<Integer, Integer>> colMapping;
+  private Map<Integer, Map<Integer, Integer>> diagonalMapping;
+  
+  private final int LEFT_DIAGONAL = 1;
+  private final int RIGHT_DIAGONAL = -1;
+  
   public TicTacToe(int n) {
-    board = new int[n][n];
-    rowMap = new HashMap<>();
-    colMap = new HashMap<>();
-    leftDiagonalMap = new HashMap<>();
-    rightDiagonalMap = new HashMap<>();
     this.n = n;
+    this.rowMapping = new HashMap<>();
+    this.colMapping = new HashMap<>();
+    this.diagonalMapping = new HashMap<>();
+    this.diagonalMapping.put(LEFT_DIAGONAL, new HashMap<>());
+    this.diagonalMapping.put(RIGHT_DIAGONAL, new HashMap<>());
   }
 
-  /** Player {player} makes a move at ({row}, {col}).
-      @param row The row of the board.
-      @param col The column of the board.
-      @param player The player, can be either 1 or 2.
-      @return The current winning condition, can be either:
-              0: No one wins.
-              1: Player 1 wins.
-              2: Player 2 wins. */
   public int move(int row, int col, int player) {
-    if (!rowMap.containsKey(row)) {
-      Map<Integer, Integer> map = new HashMap<>();
-      rowMap.put(row, map);
-    }
-    rowMap.get(row).put(player, rowMap.get(row).getOrDefault(player, 0) + 1);
-    if (ifWinner(rowMap.get(row), player)) {
-      return player;
-    }
-    if (!colMap.containsKey(col)) {
-      Map<Integer, Integer> map = new HashMap<>();
-      colMap.put(col, map);
-    }
-    colMap.get(col).put(player, colMap.get(col).getOrDefault(player, 0) + 1);
-    if (ifWinner(colMap.get(col), player)) {
-      return player;
-    }
-    if (row == col) {
-      leftDiagonalMap.put(player, leftDiagonalMap.getOrDefault(player, 0) + 1);
-    }
-    if (ifWinner(leftDiagonalMap, player)) {
-      return player;
-    }
-    if (row + col == n - 1) {
-      rightDiagonalMap.put(player, rightDiagonalMap.getOrDefault(player, 0) + 1);
-    }
-    if (ifWinner(rightDiagonalMap, player)) {
+    recordMove(row, col, player);
+    if (isWinnerFound(row, col, player)) {
       return player;
     }
     return 0;
   }
   
-  private boolean ifWinner(Map<Integer, Integer> map, int player) {
-    if (map.size() > 1) {
-      return false;
+  private void recordMove(int row, int col, int player) {
+    this.rowMapping.computeIfAbsent(row, k -> new HashMap<>());
+    this.colMapping.computeIfAbsent(col, k -> new HashMap<>());
+    this.rowMapping.get(row).put(player, this.rowMapping.get(row).getOrDefault(player, 0) + 1);
+    this.colMapping.get(col).put(player, this.colMapping.get(col).getOrDefault(player, 0) + 1);
+    if (row == col) {
+      this.diagonalMapping.get(LEFT_DIAGONAL)
+        .put(player, this.diagonalMapping.get(LEFT_DIAGONAL).getOrDefault(player, 0) + 1);
+    } 
+    if (row + col + 1 == this.n) {
+      this.diagonalMapping.get(RIGHT_DIAGONAL)
+        .put(player, this.diagonalMapping.get(RIGHT_DIAGONAL).getOrDefault(player, 0) + 1);
     }
-    return map.values().stream().reduce(0, Integer::sum) == n;
+  }
+  
+  private boolean isWinnerFound(int row, int col, int player) {
+    return this.rowMapping.get(row).get(player) == this.n ||
+      this.colMapping.get(col).get(player) == this.n ||
+      this.diagonalMapping.get(LEFT_DIAGONAL).getOrDefault(player, 0) == this.n ||
+      this.diagonalMapping.get(RIGHT_DIAGONAL).getOrDefault(player, 0) == this.n;
   }
 }
 

From 543d42754ed72cb507d62e5f9945da3c3a61e065 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Apr 2022 07:40:22 -0700
Subject: [PATCH 0957/2175] Update Read N characters Given Read4.java

---
 Easy/Read N characters Given Read4.java | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/Easy/Read N characters Given Read4.java b/Easy/Read N characters Given Read4.java
index 2ba3d5a6..d8507075 100644
--- a/Easy/Read N characters Given Read4.java	
+++ b/Easy/Read N characters Given Read4.java	
@@ -1,6 +1,6 @@
 /**
  * The read4 API is defined in the parent class Reader4.
- *     int read4(char[] buf);
+ *     int read4(char[] buf4);
  */
 
 public class Solution extends Reader4 {
@@ -10,17 +10,19 @@ public class Solution extends Reader4 {
    * @return    The number of actual characters read
    */
   public int read(char[] buf, int n) {
-    boolean endOfFile = false;
-    int totalLength = 0;
-    char[] temp = new char[4];
-    while (!endOfFile && totalLength < n) {
-      int count = read4(temp);
-      endOfFile = count < 4;
-      count = Math.min(count, n - totalLength);
-      for (int i = 0; i < count; i++) {
-        buf[totalLength++] = temp[i];
+    int copied = 0;
+    int readLength = 4;
+    char[] buf4 = new char[4];
+    while (copied < n && readLength == 4) {
+      readLength = read4(buf4);
+      for (int i = 0; i < readLength; i++) {
+        if (copied == n) {
+          return copied;
+        }
+        buf[copied] = buf4[i];
+        copied++;
       }
     }
-    return totalLength;
+    return copied;
   }
 }

From c08eebf05b5f1c4e23452f4ea208a4b8090518b6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Apr 2022 09:35:29 -0700
Subject: [PATCH 0958/2175] Update Buddy Strings.java

---
 Easy/Buddy Strings.java | 58 ++++++++++++++++++-----------------------
 1 file changed, 25 insertions(+), 33 deletions(-)

diff --git a/Easy/Buddy Strings.java b/Easy/Buddy Strings.java
index c6cdc61a..e153e52d 100644
--- a/Easy/Buddy Strings.java	
+++ b/Easy/Buddy Strings.java	
@@ -1,44 +1,36 @@
 class Solution {
-  public boolean buddyStrings(String A, String B) {
-    if (A.length() != B.length()) {
+  public boolean buddyStrings(String s, String goal) {
+    if (s.length() != goal.length()) {
       return false;
     }
-    char requiredChar = '-';
-    char mismatchChar = '-';
-    int[] counter = new int[26];
-    for (int i = 0; i < A.length(); i++) {
-      if (A.charAt(i) != B.charAt(i)) {
-	      // Already done one swap hence cannot do any more swaps
-        if (requiredChar == '_') {
-          return false;
+    if (s.equals(goal)) {
+      Set<Character> set = new HashSet<>();
+      for (char c : s.toCharArray()) {
+        if (set.contains(c)) {
+          return true;
         }
-        if (requiredChar == '-') {
-          requiredChar = B.charAt(i);
-          mismatchChar = A.charAt(i);
+        set.add(c);
+      }
+      return false;
+    }
+    char[] mismatch = {'-', '-'};
+    for (int i = 0; i < s.length(); i++) {
+      if (s.charAt(i) != goal.charAt(i)) {
+        if (mismatch[0] == '|') {
+          return false;
         }
-        else {
-		      // Check if swap is possible from previous mismatch
-          if (B.charAt(i) == mismatchChar && A.charAt(i) == requiredChar) {
-            requiredChar = '_';
-          }
-          else {
-            return false;
+        if (mismatch[0] == '-') {
+          mismatch[0] = s.charAt(i);
+          mismatch[1] = goal.charAt(i);
+        } else {
+          if (goal.charAt(i) == mismatch[0] && s.charAt(i) == mismatch[1]) {
+            mismatch[0] = '|';
+            continue;
           }
+          return false;
         }
       }
-      else {
-        counter[A.charAt(i) - 'a']++;
-      }
-    }
-    if (mismatchChar != '-') {
-      return requiredChar == '_';
-    }
-    // Check if we have more than 1 occurrence of same characters. We can swap them to fulfil the condition
-    for (int i = 0; i < 26; i++) {
-      if (counter[i] > 1) {
-        return true;
-      }
     }
-    return false;
+    return mismatch[0] == '|';
   }
 }

From 7518ae0da7a29d1c3f6db0a2a2f6e5e7358bcf7d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Apr 2022 10:42:59 -0700
Subject: [PATCH 0959/2175] Update Sort the Matrix Diagonally.java

---
 Medium/Sort the Matrix Diagonally.java | 47 +++++++++++++++++++++-----
 1 file changed, 38 insertions(+), 9 deletions(-)

diff --git a/Medium/Sort the Matrix Diagonally.java b/Medium/Sort the Matrix Diagonally.java
index f0ec13f3..003410db 100644
--- a/Medium/Sort the Matrix Diagonally.java	
+++ b/Medium/Sort the Matrix Diagonally.java	
@@ -1,16 +1,45 @@
 class Solution {
   public int[][] diagonalSort(int[][] mat) {
-    Map<Integer, PriorityQueue<Integer>> map = new HashMap<>();
-    for (int i = 0; i < mat.length; i++) {
-      for (int j = 0; j < mat[0].length; j++) {
-        map.computeIfAbsent(i - j, k -> new PriorityQueue<>()).add(mat[i][j]);
-      }
+    int numRows = mat.length;
+    int numCols = mat[0].length;
+    for (int i = 0; i < numRows; i++) {
+      sortDiagonal(i, 0, mat);
     }
-    for (int i = 0; i < mat.length; i++) {
-      for (int j = 0; j < mat[0].length; j++) {
-        mat[i][j] = map.get(i - j).poll();
-      }
+    for (int i = 0; i < numCols; i++) {
+      sortDiagonal(0, i, mat);
     }
     return mat;
   }
+  
+  private void sortDiagonal(int row, int col, int[][] mat) {
+    int numRows = mat.length;
+    int numCols = mat[0].length;
+    List<Integer> diagonal = new ArrayList<>();
+    int diagonalLength = Math.min(numRows - row, numCols - col);
+    for (int i = 0; i < diagonalLength; i++) {
+      diagonal.add(mat[row + i][col + i]);
+    }
+    diagonal = countingSort(diagonal);
+    for (int i = 0; i < diagonalLength; i++) {
+      mat[row + i][col + i] = diagonal.get(i);
+    }
+  }
+  
+  private List<Integer> countingSort(List<Integer> list) {
+    int min = 1;
+    int max = 100;
+    int range = max - min + 1;
+    int[] frequency = new int[range];
+    for (int num : list) {
+      frequency[num - min]++;
+    }
+    List<Integer> sortedList = new ArrayList<>();
+    for (int i = 0; i < range; i++) {
+      int count = frequency[i];
+      while (count-- > 0) {
+        sortedList.add(i + min);
+      }
+    }
+    return sortedList;
+  }
 }

From 0eb294b529eb89c198027ad096e8f3a2549926c1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Apr 2022 14:57:07 -0700
Subject: [PATCH 0960/2175] Update Leftmost Column with at Least a One.java

---
 .../Leftmost Column with at Least a One.java  | 37 ++++++-------------
 1 file changed, 12 insertions(+), 25 deletions(-)

diff --git a/Medium/Leftmost Column with at Least a One.java b/Medium/Leftmost Column with at Least a One.java
index 2cda1b1c..8b804b8f 100644
--- a/Medium/Leftmost Column with at Least a One.java	
+++ b/Medium/Leftmost Column with at Least a One.java	
@@ -2,38 +2,25 @@
  * // This is the BinaryMatrix's API interface.
  * // You should not implement it, or speculate about its implementation
  * interface BinaryMatrix {
- *     public int get(int x, int y) {}
+ *     public int get(int row, int col) {}
  *     public List<Integer> dimensions {}
  * };
  */
 
 class Solution {
   public int leftMostColumnWithOne(BinaryMatrix binaryMatrix) {
-    List<Integer> dims = binaryMatrix.dimensions();
-    int rows = dims.get(0);
-    int cols = dims.get(1);
-    int minIdx = Integer.MAX_VALUE;
-    for (int i = 0; i < rows; i++) {
-      int idx = binarySearch(binaryMatrix, i, 0, cols - 1);
-      if (idx != -1) {
-        minIdx = Math.min(minIdx, idx);
+    List<Integer> dimension = binaryMatrix.dimensions();
+    int numRows = dimension.get(0);
+    int numCols = dimension.get(1);
+    int currRow = 0;
+    int currCol = numCols - 1;
+    while (currRow < numRows && currCol >= 0) {
+      if (binaryMatrix.get(currRow, currCol) == 0) {
+        currRow++;
+      } else {
+        currCol--;
       }
     }
-    return minIdx == Integer.MAX_VALUE ? -1 : minIdx;
-  }
-  
-  private int binarySearch(BinaryMatrix binaryMatrix, int row, int start, int end) {
-    int minIdx = Integer.MAX_VALUE;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (binaryMatrix.get(row, mid) == 1) {
-        minIdx = Math.min(minIdx, mid);
-        end = mid - 1;
-      }
-      else {
-        start = mid + 1;
-      }
-    }
-    return minIdx == Integer.MAX_VALUE ? -1 : minIdx;
+    return currCol == numCols - 1 ? -1 : currCol + 1;
   }
 }

From b980b29f79192cb0092364cc7f5f194d9fb52eec Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Apr 2022 06:38:38 -0700
Subject: [PATCH 0961/2175] Update Squares of a Sorted Array.java

---
 Easy/Squares of a Sorted Array.java | 41 ++++++++++++++++-------------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/Easy/Squares of a Sorted Array.java b/Easy/Squares of a Sorted Array.java
index 1658e567..5308f168 100644
--- a/Easy/Squares of a Sorted Array.java	
+++ b/Easy/Squares of a Sorted Array.java	
@@ -1,27 +1,32 @@
 class Solution {
   public int[] sortedSquares(int[] nums) {
-    int n = nums.length;
-    int[] squareSorted = new int[n];
-    int start = 0;
-    while (start < n && nums[start] < 0) {
-      start++;
-    }
-    int end = start;
-    start -= 1;
-    int idx = 0;
-    while (start >= 0 || end < n) {
-      if (start >= 0 && end < n) {
-        if (nums[start] * nums[start] > nums[end] * nums[end]) {
-          squareSorted[idx++] = nums[end] * nums[end++];
+    int firstNegativeIdx = nums[0] < 0 ? 0 : nums.length;
+    int lastPositiveIdx = nums[nums.length - 1] >= 0 ? nums.length - 1 : -1;
+    int[] result = new int[nums.length];
+    int idx = result.length - 1;
+    while (idx >= 0) {
+      if (firstNegativeIdx < nums.length && lastPositiveIdx >= 0) {
+        if (Math.abs(nums[firstNegativeIdx]) > nums[lastPositiveIdx]) {
+          result[idx--] = nums[firstNegativeIdx] * nums[firstNegativeIdx];
+          firstNegativeIdx++;
+          if (firstNegativeIdx < nums.length && nums[firstNegativeIdx] >= 0) {
+            firstNegativeIdx = nums.length;
+          }
         } else {
-          squareSorted[idx++] = nums[start] * nums[start--];
+          result[idx--] = nums[lastPositiveIdx] * nums[lastPositiveIdx];
+          lastPositiveIdx--;
+          if (lastPositiveIdx >= 0 && nums[lastPositiveIdx] < 0) {
+            lastPositiveIdx = -1;
+          }
         }
-      } else if (start >= 0) {
-        squareSorted[idx++] = nums[start] * nums[start--];
+      } else if (firstNegativeIdx < nums.length && lastPositiveIdx < 0) {
+          result[idx--] = nums[firstNegativeIdx] * nums[firstNegativeIdx];
+          firstNegativeIdx++;
       } else {
-          squareSorted[idx++] = nums[end] * nums[end++];
+          result[idx--] = nums[lastPositiveIdx] * nums[lastPositiveIdx];
+          lastPositiveIdx--;
       }
     }
-    return squareSorted;
+    return result;
   }
 }

From 1465f4041408af759db71b314207341aaabaaa08 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Apr 2022 06:42:41 -0700
Subject: [PATCH 0962/2175] Update Custom Sort String.java

---
 Medium/Custom Sort String.java | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/Medium/Custom Sort String.java b/Medium/Custom Sort String.java
index 248a721a..ecdcb98d 100644
--- a/Medium/Custom Sort String.java	
+++ b/Medium/Custom Sort String.java	
@@ -1,16 +1,23 @@
 class Solution {
   public String customSortString(String order, String s) {
-    Map<Character, Integer> map = new HashMap<>();
-    int position = 1;
+    Map<Character, Integer> frequency = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      frequency.put(c, frequency.getOrDefault(c, 0) + 1);
+    }
+    StringBuilder sb = new StringBuilder();
     for (char c : order.toCharArray()) {
-      map.put(c, position++);
+      int count = frequency.getOrDefault(c, 0);
+      while (count-- > 0) {
+        sb.append(c);
+      }
+      frequency.put(c, 0);
+    }
+    for (Character key : frequency.keySet()) {
+      int count = frequency.getOrDefault(key, 0);
+      while (count-- > 0) {
+        sb.append(key);
+      }
     }
-    return s.chars()
-        .mapToObj(c -> (char) c)
-        .sorted(Comparator.comparing(o -> map.getOrDefault(o, 0)))
-        .collect(Collector.of(StringBuilder::new,
-          StringBuilder::append,
-          StringBuilder::append,
-          StringBuilder::toString));
+    return sb.toString();
   }
 }

From 37f520b2573adc1cc10db47c0e48b62355b16786 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Apr 2022 14:34:17 -0700
Subject: [PATCH 0963/2175] Create Count Prefixes of a Given String.java

---
 Easy/Count Prefixes of a Given String.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Count Prefixes of a Given String.java

diff --git a/Easy/Count Prefixes of a Given String.java b/Easy/Count Prefixes of a Given String.java
new file mode 100644
index 00000000..52438307
--- /dev/null
+++ b/Easy/Count Prefixes of a Given String.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public int countPrefixes(String[] words, String s) {
+    return (int) Arrays.stream(words).filter(word -> s.startsWith(word)).count();
+  }
+}

From 5541c9340b5c71e8964bf7e97327ec2afed63a87 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Apr 2022 19:01:12 -0700
Subject: [PATCH 0964/2175] Update Backspace String Compare.java

---
 Easy/Backspace String Compare.java | 56 +++++++++---------------------
 1 file changed, 17 insertions(+), 39 deletions(-)

diff --git a/Easy/Backspace String Compare.java b/Easy/Backspace String Compare.java
index b480d09f..170f9f69 100644
--- a/Easy/Backspace String Compare.java	
+++ b/Easy/Backspace String Compare.java	
@@ -1,45 +1,23 @@
 class Solution {
-  public boolean backspaceCompare(String S, String T) {
-    int i = S.length() - 1;
-    int j = T.length() - 1;
-    int skipS = 0;
-    int skipT = 0;
-    while (i >= 0 || j >= 0) {
-      while (i >= 0) {
-        if (S.charAt(i) == '#') {
-          skipS++;
-          i--;
-        }
-        else if (skipS > 0) {
-          skipS--;
-          i--;
-        }
-        else {
-          break;
-        }
-      }
-      while (j >= 0) {
-        if (T.charAt(j) == '#') {
-          skipT++;
-          j--;
-        }
-        else if (skipT > 0) {
-          skipT--;
-          j--;
-        }
-        else {
-          break;
+  public boolean backspaceCompare(String s, String t) {
+    return formBackSpaceString(s).equals(formBackSpaceString(t));
+  }
+  
+  private String formBackSpaceString(String s) {
+    Stack<Character> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
+      if (c == '#') {
+        if (!stack.isEmpty()) {
+          stack.pop();
         }
+      } else {
+        stack.push(c);
       }
-      if (i >= 0 && j >= 0 && S.charAt(i) != T.charAt(j)) {
-        return false;
-      }
-      if ((i >= 0) != (j >= 0)) {
-        return false;
-      }
-      i--;
-      j--;
     }
-    return true;
+    StringBuilder sb = new StringBuilder();
+    while (!stack.isEmpty()) {
+      sb.append(stack.pop());
+    }
+    return sb.toString();
   }
 }

From 17dde8d0ac8206a84ec2381ec63fc0aec5d87ac1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 1 May 2022 07:18:30 -0700
Subject: [PATCH 0965/2175] Create Remove Digit From Number to Maximize
 Result.java

---
 ...emove Digit From Number to Maximize Result.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Remove Digit From Number to Maximize Result.java

diff --git a/Easy/Remove Digit From Number to Maximize Result.java b/Easy/Remove Digit From Number to Maximize Result.java
new file mode 100644
index 00000000..b789ea2c
--- /dev/null
+++ b/Easy/Remove Digit From Number to Maximize Result.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public String removeDigit(String number, char digit) {
+    int lastOccurrence = -1;
+    for (int i = 0; i < number.length(); i++) {
+      if (number.charAt(i) == digit) {
+        if (i + 1 < number.length() && number.charAt(i + 1) > digit) {
+          return number.substring(0, i) + number.substring(i + 1);
+        }
+        lastOccurrence = i;
+      }
+    }
+    return number.substring(0, lastOccurrence) + number.substring(lastOccurrence + 1);
+  }
+}

From ed8ca44694e56f7436c69bbe53dba122118258b5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 1 May 2022 09:33:36 -0700
Subject: [PATCH 0966/2175] Create Minimum Consecutive Cards to Pick Up.java

---
 Medium/Minimum Consecutive Cards to Pick Up.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Minimum Consecutive Cards to Pick Up.java

diff --git a/Medium/Minimum Consecutive Cards to Pick Up.java b/Medium/Minimum Consecutive Cards to Pick Up.java
new file mode 100644
index 00000000..147cc54e
--- /dev/null
+++ b/Medium/Minimum Consecutive Cards to Pick Up.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int minimumCardPickup(int[] cards) {
+    int minCount = Integer.MAX_VALUE;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < cards.length; i++) {
+      if (map.containsKey(cards[i])) {
+        minCount = Math.min(minCount, i - map.get(cards[i]) + 1);
+      }
+      map.put(cards[i], i);
+    }
+    return minCount == Integer.MAX_VALUE ? -1 : minCount;
+  }
+}

From 9bc46611e4f6dce7a88e1cc76ee720d4d9927a6f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 1 May 2022 16:15:10 -0700
Subject: [PATCH 0967/2175] Create Minimum Average Difference.java

---
 Medium/Minimum Average Difference.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Minimum Average Difference.java

diff --git a/Medium/Minimum Average Difference.java b/Medium/Minimum Average Difference.java
new file mode 100644
index 00000000..995bcd11
--- /dev/null
+++ b/Medium/Minimum Average Difference.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int minimumAverageDifference(int[] nums) {
+    int n = nums.length;
+    long[] prefixSumArray = new long[n];
+    long currSum = 0;
+    for (int i = 0; i < n; i++) {
+      currSum += nums[i];
+      prefixSumArray[i] = currSum;
+    }
+    long minDifference = Integer.MAX_VALUE;
+    int minDifferenceIdx = -1;
+    for (int i = 0; i < n; i++) {
+      long leftAverage = prefixSumArray[i] / (i + 1);
+      long rightAverage = (i == n - 1) ? 0 : (prefixSumArray[n - 1] - prefixSumArray[i]) / (n - 1 - i);
+      long absoluteDiff = Math.abs(leftAverage - rightAverage);
+      if (minDifference > absoluteDiff) {
+        minDifference = absoluteDiff;
+        minDifferenceIdx = i;
+      }
+    }
+    return minDifferenceIdx;
+  }
+}

From b2188e01c553bf7a7a8267be6d15ea31458d7ac7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 2 May 2022 06:57:58 -0700
Subject: [PATCH 0968/2175] Update Merge Two Sorted Lists.java

---
 Easy/Merge Two Sorted Lists.java | 42 ++++++++++++++++++++------------
 1 file changed, 27 insertions(+), 15 deletions(-)

diff --git a/Easy/Merge Two Sorted Lists.java b/Easy/Merge Two Sorted Lists.java
index 7ce21fbd..cb2fff94 100644
--- a/Easy/Merge Two Sorted Lists.java	
+++ b/Easy/Merge Two Sorted Lists.java	
@@ -10,26 +10,38 @@
  */
 class Solution {
   public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
-    ListNode dummy = new ListNode(-1);
-    ListNode curr = dummy;
-    while (list1 != null || list2 != null) {
-      if (list1 != null && list2 != null) {
-        if (list1.val > list2.val) {
-          curr.next = new ListNode(list2.val);
-          list2 = list2.next;
-        } else {
-          curr.next = new ListNode(list1.val);
-          list1 = list1.next;
+    if (list1 == null || list2 == null) {
+      return list1 == null ? list2 : list1;
+    }
+    ListNode prev = null;
+    ListNode head = null;
+    while (list1 != null && list2 != null) {
+      if (list1.val <= list2.val) {
+        prev = list1;
+        if (head == null) {
+          head = list1;
         }
-      } else if (list1 != null && list2 == null) {
-        curr.next = new ListNode(list1.val);
         list1 = list1.next;
       } else {
-        curr.next = new ListNode(list2.val);
+        ListNode node = list2;
         list2 = list2.next;
+        if (prev == null) {
+          node.next = list1;
+          prev = node;
+          head = prev;
+        } else {
+          prev.next = node;
+          node.next = list1;
+          prev = node;
+        }
       }
-      curr = curr.next;
     }
-    return dummy.next;
+    if (list2 != null) {
+      prev.next = list2;
+    }
+    if (list1 != null) {
+      prev.next = list1;
+    }
+    return head;
   }
 }

From 001695a0577bebdf4ced2ccdef4f27cdc0319d0f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 2 May 2022 15:30:13 -0700
Subject: [PATCH 0969/2175] Update Closest Binary Search Tree Value.java

---
 Easy/Closest Binary Search Tree Value.java | 35 ++++++++++++----------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/Easy/Closest Binary Search Tree Value.java b/Easy/Closest Binary Search Tree Value.java
index 0f1ad50c..cbf397e0 100644
--- a/Easy/Closest Binary Search Tree Value.java	
+++ b/Easy/Closest Binary Search Tree Value.java	
@@ -4,30 +4,35 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public int closestValue(TreeNode root, double target) {
-    int[] ans = {0};
-    double minDiff = Double.MAX_VALUE;
-    helper(root, target, ans, minDiff);
-    return ans[0];
-  }
+    double[] result = {Double.MAX_VALUE, -1};
+    helper(root, target, result);
+    return (int) result[1];
+  }   
   
-  private void helper(TreeNode root, double target, int[] ans, double minDiff) {
+  private void helper(TreeNode root, double target, double[] result) {
     if (root == null) {
       return;
     }
-    if (Math.abs(root.val - target) < minDiff) {
-      minDiff = Math.abs(root.val - target);
-      ans[0] = root.val;
-    }
-    if (root.val < target) {
-      helper(root.right, target, ans, minDiff);
+    double diff = Math.abs(root.val - target);
+    if (diff <= result[0]) {
+      result[0] = diff;
+      result[1] = root.val; 
     }
-    else {
-      helper(root.left, target, ans, minDiff);
+    if (root.val > target) {
+      helper(root.left, target, result);
+    } else {
+      helper(root.right, target, result); 
     }
   }
 }

From 5f688d268b668366a8db62ae4dcce60a0a479e51 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 May 2022 07:57:29 -0700
Subject: [PATCH 0970/2175] Update Shortest Unsorted Continuous Subarray.java

---
 ...Shortest Unsorted Continuous Subarray.java | 48 +++++++------------
 1 file changed, 18 insertions(+), 30 deletions(-)

diff --git a/Easy/Shortest Unsorted Continuous Subarray.java b/Easy/Shortest Unsorted Continuous Subarray.java
index 2757ecbd..22fd54da 100644
--- a/Easy/Shortest Unsorted Continuous Subarray.java	
+++ b/Easy/Shortest Unsorted Continuous Subarray.java	
@@ -1,33 +1,21 @@
 class Solution {
-    public int findUnsortedSubarray(int[] nums) {
-        
-        int[] copy = new int[nums.length];
-        for (int i=0;i<nums.length;i++) {
-            copy[i] = nums[i];
-        }
-        
-        Arrays.sort(nums);
-        int start = 0;
-        int end = nums.length-1;
-        int ans = 0;
-        
-        while(start<end) {
-            if (nums[start] != copy[start] && nums[end] != copy[end]) {
-                ans = end-start+1;
-                break;
-            }
-            else if (nums[start] == copy[start] && nums[end] != copy[end]) {
-                start++;
-            }
-            else if (nums[start] != copy[start] && nums[end] == copy[end]) {
-                end--;
-            }
-            else if (nums[start] == copy[start] && nums[end] == copy[end]) {
-                end--;
-                start++;
-            }
-        }
-        
-        return ans;
+  public int findUnsortedSubarray(int[] nums) {
+    Stack<Integer> stack = new Stack<>();
+    int start = nums.length;
+    for (int i = 0; i < nums.length; i++) {
+      while (!stack.isEmpty() && nums[stack.peek()] > nums[i]) {
+        start = Math.min(start, stack.pop());
+      }
+      stack.push(i);
     }
+    stack.clear();
+    int end = 0;
+    for (int i = nums.length - 1; i >= 0; i--) {
+      while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
+        end = Math.max(end, stack.pop());
+      }
+      stack.push(i);
+    }
+    return end - start > 0 ? end - start + 1 : 0;
+  }
 }

From 06b495b223f9d524f9e7fdeb99fc38b35e644db8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 May 2022 07:57:48 -0700
Subject: [PATCH 0971/2175] Rename Easy/Shortest Unsorted Continuous
 Subarray.java to Medium/Shortest Unsorted Continuous Subarray.java

---
 {Easy => Medium}/Shortest Unsorted Continuous Subarray.java | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {Easy => Medium}/Shortest Unsorted Continuous Subarray.java (100%)

diff --git a/Easy/Shortest Unsorted Continuous Subarray.java b/Medium/Shortest Unsorted Continuous Subarray.java
similarity index 100%
rename from Easy/Shortest Unsorted Continuous Subarray.java
rename to Medium/Shortest Unsorted Continuous Subarray.java

From 399f4965cc4368b487c6eddfbf5c4d77826e0609 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 May 2022 13:38:56 -0700
Subject: [PATCH 0972/2175] Update Shuffle String.java

---
 Easy/Shuffle String.java | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/Easy/Shuffle String.java b/Easy/Shuffle String.java
index 5b82086f..10340050 100644
--- a/Easy/Shuffle String.java	
+++ b/Easy/Shuffle String.java	
@@ -1,9 +1,24 @@
 class Solution {
   public String restoreString(String s, int[] indices) {
-    char[] letters = new char[s.length()];
+    char[] letters = s.toCharArray();
     for (int i = 0; i < indices.length; i++) {
-      letters[indices[i]] = s.charAt(i);
+      while (indices[i] != i) {
+        swapLetter(letters, i, indices[i]);
+        swapIndex(indices, i, indices[i]); 
+      }
     }
     return String.valueOf(letters);
   }
+
+  private void swapLetter(char[] arr, int idxOne, int idxTwo) {
+    char temp = arr[idxOne];
+    arr[idxOne] = arr[idxTwo];
+    arr[idxTwo] = temp;
+  }
+
+  private void swapIndex(int[] arr, int idxOne, int idxTwo) {
+    int temp = arr[idxOne];
+    arr[idxOne] = arr[idxTwo];
+    arr[idxTwo] = temp;
+  }
 }

From cd0ecac29ce2007cf950adb7f7b23b5c70d6d521 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 May 2022 16:26:21 -0700
Subject: [PATCH 0973/2175] Update Intersection of Three Sorted Arrays.java

---
 Easy/Intersection of Three Sorted Arrays.java | 37 +++++++++++--------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/Easy/Intersection of Three Sorted Arrays.java b/Easy/Intersection of Three Sorted Arrays.java
index 71e66b1c..d7dc12e5 100644
--- a/Easy/Intersection of Three Sorted Arrays.java	
+++ b/Easy/Intersection of Three Sorted Arrays.java	
@@ -1,21 +1,28 @@
 class Solution {
   public List<Integer> arraysIntersection(int[] arr1, int[] arr2, int[] arr3) {
-    int[] counter = new int[2001];
-    updateCounter(counter, arr1);
-    updateCounter(counter, arr2);
-    updateCounter(counter, arr3);
-    List<Integer> ans = new ArrayList<>();
-    for (int i = 0; i < 2001; i++) {
-      if (counter[i] == 3) {
-        ans.add(i);
+    int idxOne = 0;
+    int idxTwo = 0;
+    int idxThree = 0;
+    List<Integer> result = new ArrayList<>();
+    while (idxOne < arr1.length && idxTwo < arr2.length && idxThree < arr3.length) {
+      if (arr1[idxOne] == arr2[idxTwo] && arr2[idxTwo] == arr3[idxThree]) {
+        result.add(arr1[idxOne]);
+        idxOne++;
+        idxTwo++;
+        idxThree++;
+      } else {
+        int max = Math.max(arr1[idxOne], Math.max(arr2[idxTwo], arr3[idxThree]));
+        if (arr1[idxOne] < max) {
+          idxOne++;
+        }
+        if (arr2[idxTwo] < max) {
+          idxTwo++;
+        }
+        if (arr3[idxThree] < max) {
+          idxThree++;
+        }
       }
     }
-    return ans;
-  }
-  
-  private void updateCounter(int[] counter, int[] arr) {
-    for (int num : arr) {
-      counter[num]++;
-    }
+    return result;
   }
 }

From c5acea2e79f6c8fda5f0c2599ac697d196b7df39 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 May 2022 16:28:02 -0700
Subject: [PATCH 0974/2175] Update Next Greater Element I.java

---
 Easy/Next Greater Element I.java | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/Easy/Next Greater Element I.java b/Easy/Next Greater Element I.java
index 8deb6de6..35234857 100644
--- a/Easy/Next Greater Element I.java	
+++ b/Easy/Next Greater Element I.java	
@@ -1,20 +1,18 @@
 class Solution {
   public int[] nextGreaterElement(int[] nums1, int[] nums2) {
+    Map<Integer, Integer> map = new HashMap<>();
     Stack<Integer> stack = new Stack<>();
-    int[] nextMaximum = new int[nums2.length];
-    Map<Integer, Integer> indexMap = new HashMap<>();
     for (int i = nums2.length - 1; i >= 0; i--) {
       while (!stack.isEmpty() && stack.peek() <= nums2[i]) {
         stack.pop();
       }
-      nextMaximum[i] = stack.isEmpty() ? -1 : stack.peek();
+      map.put(nums2[i], stack.isEmpty() ? -1 : stack.peek());
       stack.push(nums2[i]);
-      indexMap.put(nums2[i], i);
     }
-    int[] nextMaximumResult = new int[nums1.length];
+    int[] result = new int[nums1.length];
     for (int i = 0; i < nums1.length; i++) {
-      nextMaximumResult[i] = nextMaximum[indexMap.get(nums1[i])];
+      result[i] = map.getOrDefault(nums1[i], -1);
     }
-    return nextMaximumResult;
+    return result;
   }
 }

From 13fc282f2f8ad4ac4b2de4a11e6ef98d68bf114f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 May 2022 10:59:58 -0700
Subject: [PATCH 0975/2175] Update Verifying an Alien Dictionary.java

---
 Easy/Verifying an Alien Dictionary.java | 30 +++++++++++--------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/Easy/Verifying an Alien Dictionary.java b/Easy/Verifying an Alien Dictionary.java
index 9c71c049..e11a4728 100644
--- a/Easy/Verifying an Alien Dictionary.java	
+++ b/Easy/Verifying an Alien Dictionary.java	
@@ -1,31 +1,27 @@
 class Solution {
   public boolean isAlienSorted(String[] words, String order) {
-    Map<Character, Integer> dictionary = new HashMap<>();
-    for (int i = 0; i < order.length(); i++) {
-      dictionary.put(order.charAt(i), i);
+    Map<Character, Integer> map = new HashMap<>();
+    int idx = 0;
+    for (char c : order.toCharArray()) {
+      map.put(c, idx++);
     }
-    for (int i = 0; i < words.length - 1; i++) {
-      if (!hasCorrectOrder(words[i], words[i + 1], dictionary)) {
+    for (int i = 1; i < words.length; i++) {
+      if (!isSorted(words[i - 1], words[i], map)) {
         return false;
       }
     }
     return true;
   }
   
-  private boolean hasCorrectOrder(String firstWord, String secondWord, Map<Character, Integer> dictionary) {
-    int idxOne = 0;
-    int idxTwo = 0;
-    boolean correctOrder = false;
-    while (idxOne < firstWord.length() && idxTwo < secondWord.length()) {
-      int dictionaryDiff = dictionary.get(firstWord.charAt(idxOne++)) - dictionary.get(secondWord.charAt(idxTwo++));
-      if (dictionaryDiff > 0) {
+  private boolean isSorted(String wordOne, String wordTwo, Map<Character, Integer> map) {
+    for (int i = 0; i < Math.min(wordOne.length(), wordTwo.length()); i++) {
+      int diff = map.get(wordOne.charAt(i)) - map.get(wordTwo.charAt(i));
+      if (diff > 0) {
         return false;
-      } 
-      if (dictionaryDiff < 0) {
-        correctOrder = true;
-        break;
+      } else if (diff < 0) {
+        return true;
       }
     }
-    return correctOrder || firstWord.length() <= secondWord.length();
+    return wordOne.length() <= wordTwo.length();
   }
 }

From ffc081d89843f1b637d57371eb6a6d723edf55b8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 12 May 2022 07:23:50 +0530
Subject: [PATCH 0976/2175] Update Permutations II.java

---
 Medium/Permutations II.java | 39 ++++++++++++++-----------------------
 1 file changed, 15 insertions(+), 24 deletions(-)

diff --git a/Medium/Permutations II.java b/Medium/Permutations II.java
index 79757bf3..2469a285 100644
--- a/Medium/Permutations II.java	
+++ b/Medium/Permutations II.java	
@@ -1,34 +1,25 @@
 class Solution {
   public List<List<Integer>> permuteUnique(int[] nums) {
-    List<List<Integer>> ans = new ArrayList<>();
-    if (nums.length == 0) {
-      return ans;
-    }
-    List<Integer> curr = new ArrayList<>();
+    List<List<Integer>> result = new ArrayList<>();
     Arrays.sort(nums);
-    helper(nums, ans, curr, new boolean[nums.length]);
-    return ans;
+    helper(nums, result, new ArrayList<>(), new boolean[nums.length]);
+    return result;
   }
-  
-  private void helper(int[] nums, List<List<Integer>> ans, List<Integer> curr, boolean[] used) {
+    
+  private void helper(int[] nums, List<List<Integer>> result, List<Integer> curr, boolean[] visited) {
     if (curr.size() == nums.length) {
-      ans.add(new ArrayList<>(curr));
+      result.add(new ArrayList<>(curr));
+      return;
     }
-    else {
-      for (int i = 0; i < nums.length; i++) {
-        if (used[i]) {
-          continue;
-        }
-        if (i > 0 && nums[i - 1] == nums[i] && !used[i - 1]) {
-          continue;
-        }
-        used[i] = true;
-        curr.add(nums[i]);
-        helper(nums, ans, curr, used);
-        curr.remove(curr.size() - 1);
-        used[i] = false;
+    for (int i = 0; i < nums.length; i++) {
+      if (visited[i] || (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1])) {
+        continue;
       }
+      curr.add(nums[i]);
+      visited[i] = true;
+      helper(nums, result, curr, visited);
+      curr.remove(curr.size() - 1);
+      visited[i] = false;
     }
   }
 }
-

From 83e7c600062eee0f05a00f23db5e645c22a8192e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 12 May 2022 07:28:51 +0530
Subject: [PATCH 0977/2175] Create Largest 3-Same-Digit Number in String.java

---
 Easy/Largest 3-Same-Digit Number in String.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Largest 3-Same-Digit Number in String.java

diff --git a/Easy/Largest 3-Same-Digit Number in String.java b/Easy/Largest 3-Same-Digit Number in String.java
new file mode 100644
index 00000000..6d0b2680
--- /dev/null
+++ b/Easy/Largest 3-Same-Digit Number in String.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public String largestGoodInteger(String num) {
+    int largestIdx = -1;
+    for (int i = 0; i < num.length() - 2; i++) {
+      if (num.charAt(i) == num.charAt(i + 1) && num.charAt(i + 1) == num.charAt(i + 2)) {
+        if (largestIdx == -1 || num.substring(largestIdx, largestIdx + 3).compareTo(num.substring(i, i + 3)) < 0) {
+          largestIdx = i;
+        }
+      }
+    }
+    return largestIdx == -1 ? "" : num.substring(largestIdx, largestIdx + 3);
+  }
+}

From cced2df2f1fa8e73f8272079697ac740b0653a8c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 12 May 2022 11:50:20 +0530
Subject: [PATCH 0978/2175] Create Count Nodes Equal to Average of Subtree.java

---
 ...unt Nodes Equal to Average of Subtree.java | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/Count Nodes Equal to Average of Subtree.java

diff --git a/Medium/Count Nodes Equal to Average of Subtree.java b/Medium/Count Nodes Equal to Average of Subtree.java
new file mode 100644
index 00000000..a642fc31
--- /dev/null
+++ b/Medium/Count Nodes Equal to Average of Subtree.java	
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int averageOfSubtree(TreeNode root) {
+    int[] result = {0};
+    helper(root, result);
+    return result[0];
+  }
+  
+  private int[] helper(TreeNode root, int[] result) {
+    if (root == null) {
+      return new int[]{0, 0};
+    }
+    int[] left = helper(root.left, result);
+    int[] right = helper(root.right, result);
+    int sum = left[0] + right[0] + root.val;
+    int numOfNodes = left[1] + right[1] + 1;
+    int average = sum / numOfNodes;
+    if (root.val == average) {
+      result[0]++;
+    }
+    return new int[]{sum, numOfNodes};
+  }
+}

From e0157ee8e6f478553fe147d5e178658116954436 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 14 May 2022 05:52:51 +0530
Subject: [PATCH 0979/2175] Update Populating Next Right Pointers in Each Node
 II.java

---
 Medium/Populating Next Right Pointers in Each Node II.java | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/Medium/Populating Next Right Pointers in Each Node II.java b/Medium/Populating Next Right Pointers in Each Node II.java
index 96dd48fc..42c9e387 100644
--- a/Medium/Populating Next Right Pointers in Each Node II.java	
+++ b/Medium/Populating Next Right Pointers in Each Node II.java	
@@ -23,13 +23,10 @@ public Node(int _val, Node _left, Node _right, Node _next) {
 
 class Solution {
   public Node connect(Node root) {
-    if (root == null) {
-      return null;
-    }
     Queue<Node> queue = new LinkedList<>();
     queue.add(root);
     queue.add(null);
-    while (!queue.isEmpty() && queue.peek() != null) {
+    while (queue.peek() != null) {
       int size = queue.size() - 1;
       while (size-- > 0) {
         Node removed = queue.remove();

From a41e4bb94dbbbab2f0a4513c27169cd27495078a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 14 May 2022 17:59:40 +0530
Subject: [PATCH 0980/2175] Update Implement Stack using Queues.java

---
 Easy/Implement Stack using Queues.java | 82 ++++++++++++++------------
 1 file changed, 45 insertions(+), 37 deletions(-)

diff --git a/Easy/Implement Stack using Queues.java b/Easy/Implement Stack using Queues.java
index 08df7392..43c62339 100644
--- a/Easy/Implement Stack using Queues.java	
+++ b/Easy/Implement Stack using Queues.java	
@@ -1,44 +1,52 @@
-import java.util.ArrayList;
-
 class MyStack {
-
-    /** Initialize your data structure here. */
-    ArrayList<Integer> arrNew = new ArrayList<>();
-    ArrayList<Integer> arrOld = new ArrayList<>();
-
-
-    /** Push element x onto stack. */
-    public void push(int x) {
-        arrOld.add(x);
-    }
-
-    /** Removes the element on top of the stack and returns that element. */
-    public int pop() {
-        for (int i=0;i<=arrOld.size()-1;i++) {
-            arrNew.add(arrOld.get(i));
-        }
-        int k = arrNew.get(arrNew.size()-1);
-        arrNew.remove(arrNew.indexOf(k));
-
-        arrOld.clear();
-        return k;
+  
+  private Queue<Integer> primaryQueue;
+  private Queue<Integer> secondaryQueue;
+  
+  public MyStack() {
+    this.primaryQueue = new LinkedList<>();
+    this.secondaryQueue = new LinkedList<>();
+  }
+
+  public void push(int x) {
+    this.primaryQueue.add(x);
+  }
+
+  public int pop() {
+    int result = moveFromPrimaryToSecondary();
+    moveFromSecondaryToPrimary(true);
+    return result;
+  }
+
+  public int top() {
+    int result = moveFromPrimaryToSecondary();
+    moveFromSecondaryToPrimary(false);
+    return result;
+  }
+  
+  public boolean empty() {
+    return this.primaryQueue.isEmpty();
+  }
+  
+  private int moveFromPrimaryToSecondary() {
+    int last = this.primaryQueue.peek();
+    while (!this.primaryQueue.isEmpty()) {
+      last = this.primaryQueue.peek();
+      this.secondaryQueue.add(this.primaryQueue.remove());
     }
-
-    /** Get the top element. */
-    public int top() {
-        for (int i=0;i<=arrOld.size()-1;i++) {
-            arrNew.add(arrOld.get(i));
-        }
-        int k = arrNew.get(arrNew.size()-1);
-
-        arrOld.clear();
-        return k;
+    return last;
+  }
+  
+  private void moveFromSecondaryToPrimary(boolean removeLast) {
+    while (this.secondaryQueue.size() > 1) {
+      this.primaryQueue.add(this.secondaryQueue.remove());
     }
-
-    /** Returns whether the stack is empty. */
-    public boolean empty() {
-        return arrNew.size() == 0 && arrOld.size() == 0;
+    if (removeLast) {
+      this.secondaryQueue.remove();
+    } else {
+      this.primaryQueue.add(this.secondaryQueue.remove());
     }
+  }
 }
 
 /**

From 9f76b519203bc9c041fcfa02307bd0fe6cb1bde4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 16 May 2022 07:13:12 +0530
Subject: [PATCH 0981/2175] Create Find Resultant Array After Removing
 Anagrams.java

---
 ...sultant Array After Removing Anagrams.java | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Easy/Find Resultant Array After Removing Anagrams.java

diff --git a/Easy/Find Resultant Array After Removing Anagrams.java b/Easy/Find Resultant Array After Removing Anagrams.java
new file mode 100644
index 00000000..c2f0a9b0
--- /dev/null
+++ b/Easy/Find Resultant Array After Removing Anagrams.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public List<String> removeAnagrams(String[] words) {
+    List<String> result = new ArrayList<>();
+    int startIdx = 0;
+    for (int i = 1; i < words.length; i++) {
+      if (!isAnagram(words[i], words[startIdx])) {
+        result.add(words[startIdx]);
+        startIdx = i;
+      }
+    }
+    result.add(words[startIdx]);
+    return result;
+  }
+  
+  private boolean isAnagram(String wordOne, String wordTwo) {
+    if (wordOne.length() != wordTwo.length()) {
+      return false;
+    }
+    int[] counter = new int[26];
+    for (int i = 0; i < wordOne.length(); i++) {
+      counter[wordOne.charAt(i) - 'a']++;
+      counter[wordTwo.charAt(i) - 'a']--;
+    }
+    for (int i = 0; i < 26; i++) {
+      if (counter[i] != 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

From 67dc0f03eda6b8d8957b633fa03fbaebb05e39cf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 16 May 2022 07:17:39 +0530
Subject: [PATCH 0982/2175] Create Find the K-Beauty of a Number.java

---
 Easy/Find the K-Beauty of a Number.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Find the K-Beauty of a Number.java

diff --git a/Easy/Find the K-Beauty of a Number.java b/Easy/Find the K-Beauty of a Number.java
new file mode 100644
index 00000000..a2a1b9f6
--- /dev/null
+++ b/Easy/Find the K-Beauty of a Number.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int divisorSubstrings(int num, int k) {
+    String numString = String.valueOf(num);
+    int count = 0;
+    for (int i = 0; i <= numString.length() - k; i++) {
+      int substringNum = Integer.parseInt(numString.substring(i, i + k));
+      if (substringNum != 0 && num % substringNum == 0) {
+        count++;
+      }
+    }
+    return count;
+  }
+}

From bd5b77be3fe3b962d4a29514d7172721dd72af83 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 17 May 2022 13:03:42 +0530
Subject: [PATCH 0983/2175] Update Find a Corresponding Node of a Binary Tree
 in a Clone of That Tree.java

---
 ...a Binary Tree in a Clone of That Tree.java | 26 ++++++++++++++-----
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/Medium/Find a Corresponding Node of a Binary Tree in a Clone of That Tree.java b/Medium/Find a Corresponding Node of a Binary Tree in a Clone of That Tree.java
index 6be836db..0373fe3f 100644
--- a/Medium/Find a Corresponding Node of a Binary Tree in a Clone of That Tree.java	
+++ b/Medium/Find a Corresponding Node of a Binary Tree in a Clone of That Tree.java	
@@ -10,13 +10,25 @@
 
 class Solution {
   public final TreeNode getTargetCopy(final TreeNode original, final TreeNode cloned, final TreeNode target) {
-    if (original == null || original == target) {
-      return cloned;
+    Deque<TreeNode> stackOriginal = new ArrayDeque<>();
+    Deque<TreeNode> stackCloned = new ArrayDeque<>();
+    TreeNode nodeOriginal = original;
+    TreeNode nodeCloned = cloned;
+    while (!stackOriginal.isEmpty() || nodeOriginal != null) {
+      while (nodeOriginal != null) {
+        stackOriginal.add(nodeOriginal);
+        stackCloned.add(nodeCloned);
+        nodeOriginal = nodeOriginal.left;
+        nodeCloned = nodeCloned.left;
+      }
+      nodeOriginal = stackOriginal.removeLast();
+      nodeCloned = stackCloned.removeLast();
+      if (nodeOriginal == target) {
+        return nodeCloned;
+      }
+      nodeOriginal = nodeOriginal.right;
+      nodeCloned = nodeCloned.right;
     }
-    TreeNode leftResult = getTargetCopy(original.left, cloned.left, target);
-    if (leftResult != null) {
-      return leftResult;
-    }
-    return getTargetCopy(original.right, cloned.right, target);
+    return null;
   }
 }

From 5cd7930dca1318728dde13c1535fd7225bf737b5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 17 May 2022 13:53:50 +0530
Subject: [PATCH 0984/2175] Create Number of Ways to Split Array.java

---
 Medium/Number of Ways to Split Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Number of Ways to Split Array.java

diff --git a/Medium/Number of Ways to Split Array.java b/Medium/Number of Ways to Split Array.java
new file mode 100644
index 00000000..0c3f54f0
--- /dev/null
+++ b/Medium/Number of Ways to Split Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+	public int waysToSplitArray(int[] nums) {
+		long arraySum = 0;
+		for (int i = 0; i < nums.length; i++) {
+			arraySum += nums[i];
+		}
+		int ways = 0;
+    long prefixSum = 0;
+		for (int i = 0; i < nums.length - 1; i++) {
+      prefixSum += nums[i];
+			if (prefixSum >= arraySum - prefixSum) {
+				ways++;
+			}			
+		}
+		return ways;
+  }
+}

From 3fdac5f99fdc5f8d9a8e6f8c5908394dc29055f2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 17 May 2022 14:21:46 +0530
Subject: [PATCH 0985/2175] Update Number of Ways to Split Array.java

---
 Medium/Number of Ways to Split Array.java | 24 +++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Medium/Number of Ways to Split Array.java b/Medium/Number of Ways to Split Array.java
index 0c3f54f0..3cbaed3a 100644
--- a/Medium/Number of Ways to Split Array.java	
+++ b/Medium/Number of Ways to Split Array.java	
@@ -1,17 +1,17 @@
 class Solution {
-	public int waysToSplitArray(int[] nums) {
-		long arraySum = 0;
-		for (int i = 0; i < nums.length; i++) {
-			arraySum += nums[i];
-		}
-		int ways = 0;
+  public int waysToSplitArray(int[] nums) {
+    long arraySum = 0;
+    for (int i = 0; i < nums.length; i++) {
+      arraySum += nums[i];
+    }
+    int ways = 0;
     long prefixSum = 0;
-		for (int i = 0; i < nums.length - 1; i++) {
+    for (int i = 0; i < nums.length - 1; i++) {
       prefixSum += nums[i];
-			if (prefixSum >= arraySum - prefixSum) {
-				ways++;
-			}			
-		}
-		return ways;
+      if (prefixSum >= arraySum - prefixSum) {
+        ways++;
+      }			
+    }
+    return ways;
   }
 }

From c8272ac5155e54e8e6484b1887efc5bf3df52bbc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 17 May 2022 15:41:10 +0530
Subject: [PATCH 0986/2175] Create Maximum Consecutive Floors Without Special
 Floors.java

---
 ...um Consecutive Floors Without Special Floors.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Maximum Consecutive Floors Without Special Floors.java

diff --git a/Medium/Maximum Consecutive Floors Without Special Floors.java b/Medium/Maximum Consecutive Floors Without Special Floors.java
new file mode 100644
index 00000000..8d33dc1e
--- /dev/null
+++ b/Medium/Maximum Consecutive Floors Without Special Floors.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int maxConsecutive(int bottom, int top, int[] special) {
+    Arrays.sort(special);
+    int maxConsecutiveFloors = Math.max(special[0] - bottom, top - special[special.length - 1]);
+    for (int specialFloor : special) {
+      int emptyFloors = specialFloor - bottom;
+      bottom = specialFloor + 1;
+      maxConsecutiveFloors = Math.max(maxConsecutiveFloors, emptyFloors);
+    }
+    return maxConsecutiveFloors;
+  }
+}

From 8b4e2559dd54c138c3b4dee8ad4828a742f8855e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 18 May 2022 15:45:40 +0530
Subject: [PATCH 0987/2175] Create Critical Connections in a Network.java

---
 Hard/Critical Connections in a Network.java | 49 +++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 Hard/Critical Connections in a Network.java

diff --git a/Hard/Critical Connections in a Network.java b/Hard/Critical Connections in a Network.java
new file mode 100644
index 00000000..92d73cb4
--- /dev/null
+++ b/Hard/Critical Connections in a Network.java	
@@ -0,0 +1,49 @@
+class Solution {
+  public List<List<Integer>> criticalConnections(int n, List<List<Integer>> connections) {
+    Map<Integer, List<Integer>> graph = new HashMap<>();
+    Map<Integer, Integer> rank = new HashMap<>();
+    Set<String> connectionSet = new HashSet<>();
+    buildGraph(n, connections, graph, rank, connectionSet);
+    dfs(0, 0, graph, rank, connectionSet);
+    List<List<Integer>> result = new ArrayList<>();
+    for (String conn : connectionSet) {
+      int nodeOne = Integer.parseInt(conn.split("-")[0]);
+      int nodeTwo = Integer.parseInt(conn.split("-")[1]);
+      result.add(Arrays.asList(nodeOne, nodeTwo));
+    }
+    return result;
+  }
+  
+  private void buildGraph(int n, List<List<Integer>> connections, Map<Integer, List<Integer>> graph, Map<Integer, Integer> rank, Set<String> connectionSet) {
+    for (int i = 0; i < n; i++) {
+      graph.put(i, new ArrayList<>());
+      rank.put(i, null);
+    }
+    for (List<Integer> edge : connections) {
+      graph.get(edge.get(0)).add(edge.get(1));
+      graph.get(edge.get(1)).add(edge.get(0));
+      connectionSet.add(
+        Math.min(edge.get(0), edge.get(1)) + "-" + Math.max(edge.get(0), edge.get(1)));
+    }
+  }
+  
+  private int dfs(int node, int discoveryRank, Map<Integer, List<Integer>> graph, Map<Integer, Integer> rank, Set<String> connectionSet) {
+    if (rank.get(node) != null) {
+      return rank.get(node);
+    }
+    rank.put(node, discoveryRank);
+    int minimumRank = discoveryRank + 1;
+    for (Integer neighbor : graph.get(node)) {
+      Integer neighborRank = rank.get(neighbor);
+      if (neighborRank != null && neighborRank == discoveryRank - 1) {
+        continue;
+      }
+      int recursiveRank = dfs(neighbor, discoveryRank + 1, graph, rank, connectionSet);
+      if (recursiveRank <= discoveryRank) {
+        connectionSet.remove(Math.min(node, neighbor) + "-" + Math.max(node, neighbor));
+      }
+      minimumRank = Math.min(minimumRank, recursiveRank);
+    }
+    return minimumRank;
+  }
+}

From d1c151fda43e77a9384da9cbd12f59570595a989 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 18 May 2022 16:29:01 +0530
Subject: [PATCH 0988/2175] Update Sort Colors.java

---
 Medium/Sort Colors.java | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Medium/Sort Colors.java b/Medium/Sort Colors.java
index 1bbb3b95..6bfe64e8 100644
--- a/Medium/Sort Colors.java	
+++ b/Medium/Sort Colors.java	
@@ -2,21 +2,18 @@ class Solution {
   public void sortColors(int[] nums) {
     int zeroIdx = 0;
     int twoIdx = nums.length - 1;
-    int currIdx = 0;
-    while (currIdx <= twoIdx) {
-      if (nums[currIdx] == 0) {
-        swap(nums, currIdx++, zeroIdx++);
-      } else if (nums[currIdx] == 2) {
-        swap(nums, currIdx, twoIdx--);
+    for (int i = 0; i <= twoIdx; ) {
+      if (nums[i] == 0 && i != zeroIdx) {
+        int temp = nums[zeroIdx];
+        nums[zeroIdx++] = nums[i];
+        nums[i] = temp;
+      } else if (nums[i] == 2 && i != twoIdx) {
+        int temp = nums[twoIdx];
+        nums[twoIdx--] = nums[i];
+        nums[i] = temp;
       } else {
-        currIdx++;
+        i++;
       }
     }
   }
-  
-  private void swap(int[] nums, int idxOne, int idxTwo) {
-    int temp = nums[idxTwo];
-    nums[idxTwo] = nums[idxOne];
-    nums[idxOne] = temp;
-  }
 }

From 3d4b057d6d0e3d96bff422ca4b7944bf0d12f51f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 19 May 2022 05:32:43 +0530
Subject: [PATCH 0989/2175] Update and rename Delete node in a linked list.java
 to Delete Node in a Linked List.java

---
 Easy/Delete Node in a Linked List.java | 15 +++++++++++++++
 Easy/Delete node in a linked list.java | 14 --------------
 2 files changed, 15 insertions(+), 14 deletions(-)
 create mode 100644 Easy/Delete Node in a Linked List.java
 delete mode 100644 Easy/Delete node in a linked list.java

diff --git a/Easy/Delete Node in a Linked List.java b/Easy/Delete Node in a Linked List.java
new file mode 100644
index 00000000..0cfa6304
--- /dev/null
+++ b/Easy/Delete Node in a Linked List.java	
@@ -0,0 +1,15 @@
+/**
+* Definition for singly-linked list.
+* public class ListNode {
+*     int val;
+*     ListNode next;
+*     ListNode(int x) { val = x; }
+* }
+*/
+class Solution {
+  public void deleteNode(ListNode node) {
+    int nextVal = node.next.val;
+    node.next = node.next.next;
+    node.val = nextVal;
+  }
+}
diff --git a/Easy/Delete node in a linked list.java b/Easy/Delete node in a linked list.java
deleted file mode 100644
index 3704d05b..00000000
--- a/Easy/Delete node in a linked list.java	
+++ /dev/null
@@ -1,14 +0,0 @@
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public void deleteNode(ListNode node) {
-        node.val = node.next.val;
-        node.next=node.next.next;
-    }
-}
\ No newline at end of file

From be9503e25581545b8c1ee838ab1418098ce6fb4c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 19 May 2022 06:51:28 +0530
Subject: [PATCH 0990/2175] Update Longest Increasing Path in a Matrix.java

---
 Hard/Longest Increasing Path in a Matrix.java | 58 +++++++++----------
 1 file changed, 26 insertions(+), 32 deletions(-)

diff --git a/Hard/Longest Increasing Path in a Matrix.java b/Hard/Longest Increasing Path in a Matrix.java
index 6ba938a2..e7c7f819 100644
--- a/Hard/Longest Increasing Path in a Matrix.java	
+++ b/Hard/Longest Increasing Path in a Matrix.java	
@@ -1,36 +1,30 @@
 class Solution {
-    int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-    public int longestIncreasingPath(int[][] matrix) {
-        if (matrix.length == 0 || matrix[0].length == 0) {
-            return 0;
-        }
-        
-        int[][] dp = new int[matrix.length][matrix[0].length];
-        int max = 0;
-        for (int i = 0; i < matrix.length; i++) {
-            for (int j = 0; j < matrix[0].length; j++) {
-                max = Math.max(max, dfs(matrix, i, j, dp, Integer.MIN_VALUE));
-            }
-        }
-        
-        return max;
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+  public int longestIncreasingPath(int[][] matrix) {
+    int numRows = matrix.length;
+    int numCols = matrix[0].length;
+    int maxPathLength = 0;
+    int[][] cache = new int[numRows][numCols];
+    for (int i = 0; i < numRows; i++) {
+      for (int j = 0; j < numCols; j++) {
+        maxPathLength = Math.max(maxPathLength, helper(matrix, numRows, numCols, i, j, cache));
+      }
     }
-    
-    private int dfs(int[][] matrix, int x, int y, int[][] dp, int prevVal) {
-        if (x < 0 || x >= matrix.length || y < 0 || y >= matrix[0].length || matrix[x][y] <= prevVal) {
-            return 0;
-        }
-        
-        if (dp[x][y] != 0) {
-            return dp[x][y];
-        }
-        
-        int temp = 0;
-        for (int[] dir : dirs) {
-            temp = Math.max(temp, dfs(matrix, x + dir[0], y + dir[1], dp, matrix[x][y]));
-        }
-        
-        dp[x][y] = temp + 1;
-        return dp[x][y];
+    return maxPathLength;
+  }
+
+  private int helper(int[][] matrix, int numRows, int numCols, int i, int j, int[][] cache) {
+    if (cache[i][j] != 0) {
+      return cache[i][j];
     }
+    for (int[] dir : DIRS) {
+      int x = i + dir[0];
+      int y = j + dir[1];
+      if (x >= 0 && y >= 0 && x < numRows && y < numCols && matrix[x][y] > matrix[i][j]) {
+        cache[i][j] = Math.max(cache[i][j], helper(matrix, numRows, numCols, x, y, cache));
+      }
+    }
+    return ++cache[i][j];
+  }
 }

From c3251f93973b11d8604ba179b9d3da9a3117bdda Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 21 May 2022 07:59:35 -0700
Subject: [PATCH 0991/2175] Update Unique Paths.java

---
 Medium/Unique Paths.java | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/Medium/Unique Paths.java b/Medium/Unique Paths.java
index 8f1be73d..87e5f34e 100644
--- a/Medium/Unique Paths.java	
+++ b/Medium/Unique Paths.java	
@@ -1,20 +1,14 @@
 class Solution {
   public int uniquePaths(int m, int n) {
-    Integer[][] dp = new Integer[m][n];
-    return helper(0, 0, m, n, dp);
-  }
-  
-  private int helper(int currX, int currY, int m, int n, Integer[][] dp) {
-    if (currX == m - 1 && currY == n - 1) {
-      return 1;
-    }
-    if (currX >= m || currY >= n) {
-      return 0;
+    int[][] dp = new int[m][n];
+    for (int[] arr : dp) {
+      Arrays.fill(arr, 1);
     }
-    if (dp[currX][currY] != null) {
-      return dp[currX][currY];
+    for (int i = 1; i < m; i++) {
+      for (int j = 1; j < n; j++) {
+        dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+      }
     }
-    dp[currX][currY] = helper(currX + 1, currY, m, n, dp) + helper(currX, currY + 1, m, n, dp);
-    return dp[currX][currY];
+    return dp[m - 1][n - 1];
   }
 }

From 253658143ecaa6d2b6e84577e10ef391688da94a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 21 May 2022 08:52:09 -0700
Subject: [PATCH 0992/2175] Update Sign of the Product of an Array.java

---
 Easy/Sign of the Product of an Array.java | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/Easy/Sign of the Product of an Array.java b/Easy/Sign of the Product of an Array.java
index bbd0d67d..8f286c24 100644
--- a/Easy/Sign of the Product of an Array.java	
+++ b/Easy/Sign of the Product of an Array.java	
@@ -1,6 +1,12 @@
 class Solution {
   public int arraySign(int[] nums) {
-    return Arrays.stream(nums).filter(num -> num == 0).map(e -> 0).findAny()
-        .orElse(Arrays.stream(nums).filter(num -> num < 0).count() % 2 == 0 ? 1 : -1);
+    int negativeCount = 0;
+    for (int num : nums) {
+      if (num == 0) {
+        return 0;
+      }
+      negativeCount += num < 0 ? 1 : 0;
+    }
+    return negativeCount % 2 == 0 ? 1 : -1;
   }
 }

From 8b600216422f278b10abf949bdd468632c63e5e3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 22 May 2022 14:22:15 -0700
Subject: [PATCH 0993/2175] Create Percentage of Letter in String.java

---
 Easy/Percentage of Letter in String.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Percentage of Letter in String.java

diff --git a/Easy/Percentage of Letter in String.java b/Easy/Percentage of Letter in String.java
new file mode 100644
index 00000000..96c0526c
--- /dev/null
+++ b/Easy/Percentage of Letter in String.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int percentageLetter(String s, char letter) {
+    int letterCount = 0;
+    for (char c : s.toCharArray()) {
+      if (c == letter) {
+        letterCount++;
+      }
+    }
+    return (letterCount * 100) / s.length();
+  }
+}

From d8777ec4057551232ca819fbcf4ea47ac59a287b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 22 May 2022 14:30:34 -0700
Subject: [PATCH 0994/2175] Create Maximum Bags With Full Capacity of
 Rocks.java

---
 .../Maximum Bags With Full Capacity of Rocks.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Maximum Bags With Full Capacity of Rocks.java

diff --git a/Medium/Maximum Bags With Full Capacity of Rocks.java b/Medium/Maximum Bags With Full Capacity of Rocks.java
new file mode 100644
index 00000000..e73a7826
--- /dev/null
+++ b/Medium/Maximum Bags With Full Capacity of Rocks.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int maximumBags(int[] capacity, int[] rocks, int additionalRocks) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    for (int i = 0; i < capacity.length; i++) {
+      pq.add(capacity[i] - rocks[i]);
+    }
+    while (!pq.isEmpty()) {
+      if (pq.peek() > additionalRocks) {
+        return capacity.length - pq.size();
+      }
+      additionalRocks -= pq.poll();
+    }
+    return capacity.length;
+  }
+}

From 17e21d1025a861a4c61ecb5c99afe1782177ecd1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 22 May 2022 17:24:15 -0700
Subject: [PATCH 0995/2175] Create Ones and Zeroes.java

---
 Medium/Ones and Zeroes.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Ones and Zeroes.java

diff --git a/Medium/Ones and Zeroes.java b/Medium/Ones and Zeroes.java
new file mode 100644
index 00000000..d4e6335f
--- /dev/null
+++ b/Medium/Ones and Zeroes.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public int findMaxForm(String[] strs, int m, int n) {
+    int[][] dp = new int[m + 1][n + 1];
+    for (String s : strs) {
+      int[] count = getCountForZeroAndOne(s);
+      for (int zeroes = m; zeroes >= count[0]; zeroes--) {
+        for (int ones = n; ones >= count[1]; ones--) {
+          dp[zeroes][ones] = Math.max(1 + dp[zeroes - count[0]][ones - count[1]], dp[zeroes][ones]);
+        }
+      }
+    }
+    return dp[m][n];
+  }
+  
+  private int[] getCountForZeroAndOne(String s) {
+    int[] count = {0, 0};
+    for (char c : s.toCharArray()) {
+      if (c == '0') {
+        count[0]++;
+      } else {
+        count[1]++;
+      }
+    }
+    return count;
+  }
+}

From 7b54544c6ba7c3554a9f632f4e250512656a6612 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 May 2022 07:07:48 -0700
Subject: [PATCH 0996/2175] Update 1-bit and 2-bit Characters.java

---
 Easy/1-bit and 2-bit Characters.java | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/Easy/1-bit and 2-bit Characters.java b/Easy/1-bit and 2-bit Characters.java
index c2031613..f58ff16a 100644
--- a/Easy/1-bit and 2-bit Characters.java	
+++ b/Easy/1-bit and 2-bit Characters.java	
@@ -1,20 +1,12 @@
 class Solution {
   public boolean isOneBitCharacter(int[] bits) {
     int idx = 0;
-    int n = bits.length; 
-    while (idx < n) {
-      if (bits[idx] == 1) {
-        if (idx + 1 == n - 1) {
-          return false;
-        }
-        else {
-          idx += 2;
-        }
-      }
-      else {
+    while (idx < bits.length - 1) {
+      if (bits[idx] != 0) {
         idx++;
       }
+      idx++;
     }
-    return true;
-  }
+    return idx == bits.length - 1;
+  } 
 }

From 972071a5831530e288bb02d8cc2eae1f5613f759 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 May 2022 07:32:38 -0700
Subject: [PATCH 0997/2175] Update Majority Element II.java

---
 Medium/Majority Element II.java | 30 +++++++++++++-----------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/Medium/Majority Element II.java b/Medium/Majority Element II.java
index 4d55d74e..a44275b4 100644
--- a/Medium/Majority Element II.java	
+++ b/Medium/Majority Element II.java	
@@ -1,25 +1,21 @@
 class Solution {
   public List<Integer> majorityElement(int[] nums) {
+    Integer majorityElementOne = null;
+    Integer majorityElementTwo = null;
     int countOne = 0;
     int countTwo = 0;
-    Integer candidateOne = null;
-    Integer candidateTwo = null;
     for (int num : nums) {
-      if (candidateOne != null && candidateOne == num) {
+      if (majorityElementOne != null && num == majorityElementOne) {
         countOne++;
-      }
-      else if (candidateTwo != null && candidateTwo == num) {
+      } else if (majorityElementTwo != null && num == majorityElementTwo) {
         countTwo++;
-      }
-      else if (countOne == 0) {
-        candidateOne = num;
+      } else if (countOne == 0) {
+        majorityElementOne = num;
         countOne = 1;
-      }
-      else if (countTwo == 0) {
-        candidateTwo = num;
+      } else if (countTwo == 0) {
+        majorityElementTwo = num;
         countTwo = 1;
-      }
-      else {
+      } else {
         countOne--;
         countTwo--;
       }
@@ -28,18 +24,18 @@ else if (countTwo == 0) {
     countOne = 0;
     countTwo = 0;
     for (int num : nums) {
-      if (candidateOne != null && candidateOne == num) {
+      if (majorityElementOne != null && majorityElementOne == num) {
         countOne++;
       }
-      else if (candidateTwo != null && candidateTwo == num) {
+      if (majorityElementTwo != null && majorityElementTwo == num) {
         countTwo++;
       }
     }
     if (countOne > nums.length / 3) {
-      result.add(candidateOne);
+      result.add(majorityElementOne);
     }
     if (countTwo > nums.length / 3) {
-      result.add(candidateTwo);
+      result.add(majorityElementTwo);
     }
     return result;
   }

From 90e405c538076acbd10b6206e1ec5e071f8bf519 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 May 2022 10:58:49 -0700
Subject: [PATCH 0998/2175] Create Friends Of Appropriate Ages.java

---
 Medium/Friends Of Appropriate Ages.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Friends Of Appropriate Ages.java

diff --git a/Medium/Friends Of Appropriate Ages.java b/Medium/Friends Of Appropriate Ages.java
new file mode 100644
index 00000000..8d63064c
--- /dev/null
+++ b/Medium/Friends Of Appropriate Ages.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int numFriendRequests(int[] ages) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int age : ages) {
+      map.put(age, map.getOrDefault(age, 0) + 1);
+    }
+    int totalFriendRequests = 0;
+    for (Integer ageOne : map.keySet()) {
+      for (Integer ageTwo : map.keySet()) {
+        if (!((ageTwo <= 0.5 * ageOne + 7) || (ageTwo > ageOne) || (ageTwo > 100 && ageOne < 100))) {
+          totalFriendRequests += map.get(ageOne) * (map.get(ageTwo) - (ageOne == ageTwo ? 1 : 0));
+        }
+      }
+    }
+    return totalFriendRequests;
+  }
+}

From 6b0ffffae799facb223796bce58e9f7440bd199c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 May 2022 11:22:25 -0700
Subject: [PATCH 0999/2175] Update Check Completeness of a Binary Tree.java

---
 .../Check Completeness of a Binary Tree.java  | 34 ++++++++-----------
 1 file changed, 14 insertions(+), 20 deletions(-)

diff --git a/Medium/Check Completeness of a Binary Tree.java b/Medium/Check Completeness of a Binary Tree.java
index a0f1e5f5..30ee5adb 100644
--- a/Medium/Check Completeness of a Binary Tree.java	
+++ b/Medium/Check Completeness of a Binary Tree.java	
@@ -15,27 +15,21 @@
  */
 class Solution {
   public boolean isCompleteTree(TreeNode root) {
-    List<HelperNode> nodes = new ArrayList<>();
-    nodes.add(new HelperNode(root, 1));
-    int idx = 0 ;
-    while (idx < nodes.size()) {
-      HelperNode hnode = nodes.get(idx++);
-      if (hnode.node != null) {
-        nodes.add(new HelperNode(hnode.node.left, 2 * hnode.level));
-        nodes.add(new HelperNode(hnode.node.right, 2 * hnode.level + 1));
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    boolean end = false;
+    while (!queue.isEmpty()) {
+      TreeNode removed = queue.poll();
+      if (removed == null) {
+        end = true;
+      } else {
+        if (end) {
+          return false;
+        }
+        queue.add(removed.left);
+        queue.add(removed.right);
       }
     }
-    return nodes.get(idx - 1).level == nodes.size();
-  }
-}
-
-
-class HelperNode {
-  TreeNode node;
-  int level;
-  
-  public HelperNode(TreeNode node, int level) {
-    this.node = node;
-    this.level = level;
+    return true;
   }
 }

From a054043a8c5171c8f156c5037e3f86ba1b4e12cd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 May 2022 13:52:55 -0700
Subject: [PATCH 1000/2175] Update Palindrome Number.java

---
 Easy/Palindrome Number.java | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/Easy/Palindrome Number.java b/Easy/Palindrome Number.java
index 6c5be699..a3206088 100644
--- a/Easy/Palindrome Number.java	
+++ b/Easy/Palindrome Number.java	
@@ -3,15 +3,13 @@ public boolean isPalindrome(int x) {
     if (x < 0) {
       return false;
     }
-    return x - reverse(x) == 0;
-  }
-  
-  private int reverse(int n) {
-    int newNum = 0;
-    while (n > 0) {
-      newNum = newNum * 10 + n % 10;
-      n /= 10;
+    int reversedNum = 0;
+    int xCopy = x;
+    while (x > 0) {
+      int rem = x % 10;
+      reversedNum = reversedNum * 10 + rem;
+      x /= 10;
     }
-    return newNum;
+    return reversedNum == xCopy;
   }
 }

From 01cd82a0f5160389a8a547a8e6d598e6a5aa94ad Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 May 2022 15:24:18 -0700
Subject: [PATCH 1001/2175] Update Remove Element.java

---
 Easy/Remove Element.java | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/Easy/Remove Element.java b/Easy/Remove Element.java
index f879483d..c75e9bb7 100644
--- a/Easy/Remove Element.java	
+++ b/Easy/Remove Element.java	
@@ -1,14 +1,11 @@
 class Solution {
   public int removeElement(int[] nums, int val) {
-    int start = 0;
-    int end = 0;
-    int n = nums.length;
-    while (end < n) {
-      if (nums[end] != val) {
-        nums[start++] = nums[end];
+    int idx = 0;
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] != val) {
+        nums[idx++] = nums[i];
       }
-      end++;
     }
-    return start;
+    return idx;
   }
 }

From 44323f051ed01a0f3d8e38376774356afee48941 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 May 2022 04:48:27 -0700
Subject: [PATCH 1002/2175] Create Longest Valid Parentheses.java

---
 Hard/Longest Valid Parentheses.java | 34 +++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Hard/Longest Valid Parentheses.java

diff --git a/Hard/Longest Valid Parentheses.java b/Hard/Longest Valid Parentheses.java
new file mode 100644
index 00000000..5f0d934c
--- /dev/null
+++ b/Hard/Longest Valid Parentheses.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public int longestValidParentheses(String s) {
+    int maxLength = 0;
+    int leftIdx = 0;
+    int rightIdx = 0;
+    for (int i = 0; i < s.length(); i++) {
+      if (s.charAt(i) == '(') {
+        leftIdx++;
+      } else {
+        rightIdx++;
+      }
+      if (leftIdx == rightIdx) {
+        maxLength = Math.max(maxLength, 2 * rightIdx);
+      } else if (rightIdx > leftIdx) {
+        leftIdx = rightIdx = 0;
+      }
+    }
+    leftIdx = 0;
+    rightIdx = 0;
+    for (int i = s.length() - 1; i >= 0; i--) {
+      if (s.charAt(i) == '(') {
+        leftIdx++;
+      } else {
+        rightIdx++;
+      }
+      if (leftIdx == rightIdx) {
+        maxLength = Math.max(maxLength, 2 * rightIdx);
+      } else if (leftIdx > rightIdx) {
+        leftIdx = rightIdx = 0;
+      }
+    }
+    return maxLength;
+  }
+}

From 1d353a55ebfe30a17dfd3601460515d19653db60 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 May 2022 05:23:00 -0700
Subject: [PATCH 1003/2175] Update Reorder Data in Log Files.java

---
 Easy/Reorder Data in Log Files.java | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/Easy/Reorder Data in Log Files.java b/Easy/Reorder Data in Log Files.java
index 86d8786d..e924d7ab 100644
--- a/Easy/Reorder Data in Log Files.java	
+++ b/Easy/Reorder Data in Log Files.java	
@@ -10,16 +10,9 @@ public String[] reorderLogFiles(String[] logs) {
         letterLogs.add(log);
       }
     }
-    letterLogs.sort((o1, o2) -> {
-      String contentOne = o1.substring(o1.indexOf(" ") + 1);
-      String contentTwo = o2.substring(o2.indexOf(" ") + 1);
-      int c = contentOne.compareTo(contentTwo);
-      if (c != 0) {
-        return c;
-      }
-      return o1.substring(0, o1.indexOf(" ")).compareTo(o2.substring(0, o2.indexOf(" ")));
-    });
+    letterLogs.sort(Comparator.comparing((String o) -> o.substring(o.indexOf(' ') + 1))
+        .thenComparing(o -> o.substring(0, o.indexOf(' '))));
     letterLogs.addAll(digitLogs);
-    return letterLogs.toArray(new String[0]);
-  }
+    return letterLogs.toArray(new String[]{});
+  } 
 }

From c4e3fcaab1b6cb4f5fb608adfe43a41ce19f9665 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 May 2022 05:24:00 -0700
Subject: [PATCH 1004/2175] Update Generate Parentheses.java

---
 Medium/Generate Parentheses.java | 42 +++++++++++++++-----------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/Medium/Generate Parentheses.java b/Medium/Generate Parentheses.java
index 7b311c92..5d22b059 100644
--- a/Medium/Generate Parentheses.java	
+++ b/Medium/Generate Parentheses.java	
@@ -1,30 +1,28 @@
 class Solution {
-  Set<String> set;
   public List<String> generateParenthesis(int n) {
-    set = new HashSet<>();
-    StringBuilder sb = new StringBuilder();
-    helper(n, 0, 0, sb);
-    return new ArrayList<>(set);
+    List<String> result = new ArrayList<>();
+    helper(result, 0, 0, n, new StringBuilder());
+    return result;
   }
   
-  private void helper(int n, int open, int close, StringBuilder sb) {
-    if (sb.length() == 2 * n) {
-      set.add(sb.toString());
-    }
-    else {
-      if (open <= close) {
-        sb.append('(');
-        helper(n, open + 1, close, new StringBuilder(sb.toString()));
-      }
-      else {
-        sb.append(')');
-        helper(n, open, close + 1, new StringBuilder(sb.toString()));
-        sb.deleteCharAt(sb.length() - 1);
-        if (open < n) {
-          sb.append('(');
-          helper(n, open + 1, close, new StringBuilder(sb.toString())); 
-        }
+  private void helper(List<String> result, int start, int end, int n, StringBuilder sb) {
+    if (start + end == 2 * n) {
+      if (start == end) {
+        result.add(new StringBuilder(sb.toString()).toString());
       }
+      return;
+    }
+    if (start > end) {
+      sb.append('(');
+      helper(result, start + 1, end, n, sb);
+      sb.deleteCharAt(sb.length() - 1);
+      sb.append(')');
+      helper(result, start, end + 1, n, sb);
+      sb.deleteCharAt(sb.length() - 1);
+    } else if (start == end) {
+      sb.append('(');
+      helper(result, start + 1, end, n, sb);
+      sb.deleteCharAt(sb.length() - 1);
     }
   }
 }

From de0a584947394ab439df7fa80cbbbcac37694fd6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 May 2022 07:05:33 -0700
Subject: [PATCH 1005/2175] Update and rename Sum of left leaves.java to Sum of
 Left Leaves.java

---
 ...ft leaves.java => Sum of Left Leaves.java} | 31 ++++++++++---------
 1 file changed, 16 insertions(+), 15 deletions(-)
 rename Easy/{Sum of left leaves.java => Sum of Left Leaves.java} (52%)

diff --git a/Easy/Sum of left leaves.java b/Easy/Sum of Left Leaves.java
similarity index 52%
rename from Easy/Sum of left leaves.java
rename to Easy/Sum of Left Leaves.java
index 7197aa1c..622dd1c4 100644
--- a/Easy/Sum of left leaves.java	
+++ b/Easy/Sum of Left Leaves.java	
@@ -15,25 +15,26 @@
  */
 class Solution {
   public int sumOfLeftLeaves(TreeNode root) {
-    if (root == null) {
-      return 0;
-    }
     int sum = 0;
     Queue<TreeNode[]> queue = new LinkedList<>();
     queue.add(new TreeNode[]{root, null});
     while (!queue.isEmpty()) {
-      TreeNode[] removed = queue.remove();
-      if (removed[0].left == null && removed[0].right == null) {
-        if (removed[1] != null && removed[1].left == removed[0]) {
-          sum += removed[0].val;
-        }
-      }
-      else {
-        if (removed[0].left != null) {
-          queue.add(new TreeNode[]{removed[0].left, removed[0]});
-        }
-        if (removed[0].right != null) {
-          queue.add(new TreeNode[]{removed[0].right, removed[0]});
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeNode[] removed = queue.remove();
+        TreeNode node = removed[0];
+        TreeNode parent = removed[1];
+        if (node.left == null && node.right == null) {
+          if (parent != null && parent.left == node) {
+            sum += node.val;
+          }
+        } else {
+          if (node.left != null) {
+            queue.add(new TreeNode[]{node.left, node});
+          }
+          if (node.right != null) {
+            queue.add(new TreeNode[]{node.right, node});
+          }
         }
       }
     }

From 9845f6f98ea1538a0ef70e2941beaf160b14a7dd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 May 2022 14:43:21 -0700
Subject: [PATCH 1006/2175] Update Strobogrammatic Number.java

---
 Easy/Strobogrammatic Number.java | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/Easy/Strobogrammatic Number.java b/Easy/Strobogrammatic Number.java
index c258a0c2..76ceb310 100644
--- a/Easy/Strobogrammatic Number.java	
+++ b/Easy/Strobogrammatic Number.java	
@@ -2,13 +2,11 @@ class Solution {
   public boolean isStrobogrammatic(String num) {
     StringBuilder sb = new StringBuilder();
     for (char c : num.toCharArray()) {
-      if (c == '0' || c == '1' || c == '8') {
-        sb.append(c);
-      }
-      else if (c == '6' || c == '9') {
+      if (c == '6' || c == '9') {
         sb.append(c == '6' ? '9' : '6');
-      }
-      else {
+      } else if (c == '0' || c == '8' || c == '1') {
+        sb.append(c);
+      } else {
         return false;
       }
     }

From 255b9a17444f937b27458de030b84307e1f1c62c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 May 2022 14:55:19 -0700
Subject: [PATCH 1007/2175] Update Diet Plan Performance.java

---
 Easy/Diet Plan Performance.java | 35 +++++++++++----------------------
 1 file changed, 12 insertions(+), 23 deletions(-)

diff --git a/Easy/Diet Plan Performance.java b/Easy/Diet Plan Performance.java
index 719e5797..f2cc1fab 100644
--- a/Easy/Diet Plan Performance.java	
+++ b/Easy/Diet Plan Performance.java	
@@ -1,27 +1,16 @@
 class Solution {
-    int points;
-    public int dietPlanPerformance(int[] calories, int k, int lower, int upper) {
-        points = 0;
-        int totalCal = 0;
-        int start = 0;
-        for (int i = 0; i < k; i++) {
-            totalCal += calories[i];
-        }
-        for (int i = k; i < calories.length; i++) {    
-            updatePoints(totalCal, lower, upper);
-            totalCal -= calories[start++];
-            totalCal += calories[i];
-        }
-        updatePoints(totalCal, lower, upper);
-        return points;
+  public int dietPlanPerformance(int[] calories, int k, int lower, int upper) {
+    int points = 0;
+    int totalCalories = 0;
+    for (int i = 0; i < k - 1; i++) {
+      totalCalories += calories[i];
     }
-    
-    private void updatePoints(int currCal, int lower, int upper) {
-        if (currCal < lower) {
-            points--;
-        }
-        if (currCal > upper) {
-            points++;
-        }
+    for (int i = k - 1; i < calories.length; i++) {
+      totalCalories += calories[i];
+      points += totalCalories < lower ? -1 : 0;
+      points += totalCalories > upper ? 1 : 0;
+      totalCalories -= calories[i - k + 1];
     }
+    return points;
+  }
 }

From b27a158f9d466420bb333bed555fe35a4e5d0f4b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 May 2022 14:56:05 -0700
Subject: [PATCH 1008/2175] Update Subtree of Another Tree.java

---
 Easy/Subtree of Another Tree.java | 48 +++++++++++++++++--------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/Easy/Subtree of Another Tree.java b/Easy/Subtree of Another Tree.java
index f132ee85..a88e3642 100644
--- a/Easy/Subtree of Another Tree.java	
+++ b/Easy/Subtree of Another Tree.java	
@@ -4,30 +4,36 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public boolean isSubtree(TreeNode s, TreeNode t) {
-        if (s == null) {
-            return false;
-        }
-        if (helper(s, t)) {
-            return true;
-        }
-        return isSubtree(s.left, t) || isSubtree(s.right, t);
+  public boolean isSubtree(TreeNode root, TreeNode subRoot) {
+    if (root == null) {
+      return false;
     }
-    
-    private boolean helper(TreeNode s, TreeNode t) {
-        if (s == null && t == null) {
-            return true;
-        }
-        if ((s == null && t != null) || (s != null && t == null)) {
-            return false;
-        }
-        if (s.val != t.val) {
-            return false;
-        }
-        return helper(s.left, t.left) && helper(s.right, t.right);
+    if (isSubtreeHelper(root, subRoot)) {
+      return true;
     }
+    return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
+  }
+  
+  private boolean isSubtreeHelper(TreeNode root, TreeNode subRoot) {
+    if (root == null && subRoot == null) {
+      return true;
+    }
+    if (root == null || subRoot == null) {
+      return false;
+    }
+    if (root.val != subRoot.val) {
+      return false;
+    }
+    return isSubtreeHelper(root.left, subRoot.left) && isSubtreeHelper(root.right, subRoot.right);
+  }
 }

From 48f6f53310ae121fa7af7bb498ad7a39c81c8ff2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 May 2022 15:11:44 -0700
Subject: [PATCH 1009/2175] Update and rename Medium/Rectangle Overlap.java to
 Easy/Rectangle Overlap.java

---
 Easy/Rectangle Overlap.java   |  6 ++++++
 Medium/Rectangle Overlap.java | 20 --------------------
 2 files changed, 6 insertions(+), 20 deletions(-)
 create mode 100644 Easy/Rectangle Overlap.java
 delete mode 100644 Medium/Rectangle Overlap.java

diff --git a/Easy/Rectangle Overlap.java b/Easy/Rectangle Overlap.java
new file mode 100644
index 00000000..cd471934
--- /dev/null
+++ b/Easy/Rectangle Overlap.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public boolean isRectangleOverlap(int[] rec1, int[] rec2) {
+    return (Math.min(rec1[2], rec2[2]) > Math.max(rec1[0], rec2[0]) && 
+            Math.min(rec1[3], rec2[3]) > Math.max(rec1[1], rec2[1])); 
+  }
+}
diff --git a/Medium/Rectangle Overlap.java b/Medium/Rectangle Overlap.java
deleted file mode 100644
index 26b038d2..00000000
--- a/Medium/Rectangle Overlap.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-    public boolean isRectangleOverlap(int[] rec1, int[] rec2) {
-        int rec1X1 = rec1[0];
-        int rec1X2 = rec1[2];
-        int rec1Y1 = rec1[1];
-        int rec1Y2 = rec1[3];
-        
-        int rec2X1 = rec2[0];
-        int rec2X2 = rec2[2];
-        int rec2Y1 = rec2[1];
-        int rec2Y2 = rec2[3];
-        
-        return !(
-                    rec1X1 >= rec2X2 ||
-                    rec1X2 <= rec2X1 ||
-                    rec1Y2 <= rec2Y1 ||
-                    rec1Y1 >= rec2Y2
-                );
-    }
-}

From 32f38f57ad537286625df734901789fb4bde2d1e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 08:41:55 -0700
Subject: [PATCH 1010/2175] Update and rename Easy/Reverse Integer.java to
 Medium/Reverse Integer.java

---
 Easy/Reverse Integer.java   | 17 -----------------
 Medium/Reverse Integer.java | 17 +++++++++++++++++
 2 files changed, 17 insertions(+), 17 deletions(-)
 delete mode 100644 Easy/Reverse Integer.java
 create mode 100644 Medium/Reverse Integer.java

diff --git a/Easy/Reverse Integer.java b/Easy/Reverse Integer.java
deleted file mode 100644
index 330bbff2..00000000
--- a/Easy/Reverse Integer.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-public class Solution {
-    public int reverse(int x) {
-        int result = 0;
-
-        while (x != 0)
-        {
-            int tail = x % 10;
-            int newResult = result * 10 + tail;
-            if ((newResult - tail) / 10 != result)
-            { return 0; }
-            result = newResult;
-            x = x / 10;
-        }
-
-        return result;
-    }
-}
\ No newline at end of file
diff --git a/Medium/Reverse Integer.java b/Medium/Reverse Integer.java
new file mode 100644
index 00000000..6acc2d42
--- /dev/null
+++ b/Medium/Reverse Integer.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int reverse(int x) {
+    int reverse = 0;
+    while (x != 0) {
+      int rem = x % 10;
+      x /= 10;
+      if (reverse > Integer.MAX_VALUE / 10 || (reverse == Integer.MAX_VALUE / 10 && rem > 7)) {
+        return 0;
+      }
+      if (reverse < Integer.MIN_VALUE / 10 || (reverse == Integer.MIN_VALUE / 10 && rem < -8)) {
+        return 0;
+      }
+      reverse = reverse * 10 + rem;
+    }
+    return reverse;
+  }
+}

From cb2a3bff75d18c88c374751fa35f4273637b8a96 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 08:46:24 -0700
Subject: [PATCH 1011/2175] Update Array Partition I.java

---
 Easy/Array Partition I.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Easy/Array Partition I.java b/Easy/Array Partition I.java
index 8e6012c2..9c263d99 100644
--- a/Easy/Array Partition I.java	
+++ b/Easy/Array Partition I.java	
@@ -1,18 +1,18 @@
 class Solution {
   public int arrayPairSum(int[] nums) {
-    int[] arr = new int[20001];
+    int[] counter = new int[20001];
     for (int num : nums) {
-      arr[num + 10000]++;
+      counter[num + 10000]++;
     }
     int sum = 0;
-    boolean odd = true;
-    for (int i = 0; i < arr.length; i++) {
-      while (arr[i] > 0) {
-        if (odd) {
+    boolean pickFirst = true;
+    for (int i = 0; i < counter.length; i++) {
+      while (counter[i] > 0) {
+        if (pickFirst) {
           sum += i - 10000;
         }
-        odd = !odd;
-        arr[i]--;
+        pickFirst = !pickFirst;
+        counter[i]--;
       }
     }
     return sum;

From 9cb960c41aaa7c31b153c3124a287aa3997bc21d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 12:18:47 -0700
Subject: [PATCH 1012/2175] Update Sum of Root To Leaf Binary Numbers.java

---
 Easy/Sum of Root To Leaf Binary Numbers.java | 52 +++++++++++++-------
 1 file changed, 34 insertions(+), 18 deletions(-)

diff --git a/Easy/Sum of Root To Leaf Binary Numbers.java b/Easy/Sum of Root To Leaf Binary Numbers.java
index 48133053..d49907f2 100644
--- a/Easy/Sum of Root To Leaf Binary Numbers.java	
+++ b/Easy/Sum of Root To Leaf Binary Numbers.java	
@@ -15,30 +15,46 @@
  */
 class Solution {
   public int sumRootToLeaf(TreeNode root) {
-    int[] result = {0};
-    helper(root, new StringBuilder(), result);
-    return result[0];
-  }
-  
-  private void helper(TreeNode root, StringBuilder sb, int[] result) {
-    if (root == null) {
-      return;
-    }
-    sb.append(root.val);
-    if (root.left == null && root.right == null) {
-      result[0] += getDecimalValue(sb.toString());
-      return;
+    Queue<NodeToBinaryRepresentation> queue = new LinkedList<>();
+    queue.add(new NodeToBinaryRepresentation(root, new StringBuilder()));
+    int sum = 0;
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        NodeToBinaryRepresentation removed = queue.remove();
+        StringBuilder sb = new StringBuilder().append(removed.sb.toString()).append(removed.node.val);
+        if (removed.node.left == null && removed.node.right == null) {
+          sum += getIntegerValue(sb.toString());
+        } else {
+          if (removed.node.left != null) {
+            queue.add(new NodeToBinaryRepresentation(removed.node.left, sb));
+          }
+          if (removed.node.right != null) {
+            queue.add(new NodeToBinaryRepresentation(removed.node.right, sb));
+          }
+        }
+      }
     }
-    helper(root.left, new StringBuilder(sb.toString()), result);
-    helper(root.right, new StringBuilder(sb.toString()), result);
+    return sum;
   }
   
-  private int getDecimalValue(String s) {
+  private int getIntegerValue(String s) {
     int value = 0;
-    int powerOfTwo = 0;
+    int multiplier = 1;
     for (int i = s.length() - 1; i >= 0; i--) {
-      value += ((int) Math.pow(2, powerOfTwo++)) * Character.getNumericValue(s.charAt(i));
+      value += Character.getNumericValue(s.charAt(i)) * multiplier;
+      multiplier *= 2;
     }
     return value;
   }
+  
+  private static class NodeToBinaryRepresentation {
+    TreeNode node;
+    StringBuilder sb;
+    
+    public NodeToBinaryRepresentation(TreeNode node, StringBuilder sb) {
+      this.node = node;
+      this.sb = sb;
+    }
+  }
 }

From 001718b17f3deaea9178c454b0f5419ae4abe2f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 12:19:53 -0700
Subject: [PATCH 1013/2175] Create Synonymous Sentences.java

---
 Medium/Synonymous Sentences.java | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Synonymous Sentences.java

diff --git a/Medium/Synonymous Sentences.java b/Medium/Synonymous Sentences.java
new file mode 100644
index 00000000..6de8d907
--- /dev/null
+++ b/Medium/Synonymous Sentences.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public List<String> generateSentences(List<List<String>> synonyms, String text) {
+    Map<String, List<String>> synonymMapping = new HashMap<>();
+    for (List<String> synonym : synonyms) {
+      synonymMapping.computeIfAbsent(synonym.get(0), k -> new ArrayList<>()).add(synonym.get(1));
+      synonymMapping.computeIfAbsent(synonym.get(1), k -> new ArrayList<>()).add(synonym.get(0));
+    }
+    Set<String> result = new TreeSet<>();
+    Queue<String> queue = new LinkedList<>();
+    queue.add(text);
+    while (!queue.isEmpty()) {
+      String removed = queue.remove();
+      result.add(removed);
+      String[] words = removed.split("\\s+");
+      for (int i = 0; i < words.length; i++) {
+        for (String synonym : synonymMapping.getOrDefault(words[i], new ArrayList<>())) {
+          words[i] = synonym;
+          String updatedSentence = String.join(" ", words);
+          if (!result.contains(updatedSentence)) {
+            queue.add(updatedSentence);
+          }
+        }
+      }
+    }
+    return new ArrayList<>(result);
+  }
+}

From 3fb3702aba7fd2a41632e5de0a89d1f58956c337 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 12:37:17 -0700
Subject: [PATCH 1014/2175] Update Uncommon Words from Two Sentences.java

---
 Easy/Uncommon Words from Two Sentences.java | 33 +++++++++++----------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/Easy/Uncommon Words from Two Sentences.java b/Easy/Uncommon Words from Two Sentences.java
index 4693b5c9..3b7eab9e 100644
--- a/Easy/Uncommon Words from Two Sentences.java	
+++ b/Easy/Uncommon Words from Two Sentences.java	
@@ -1,19 +1,20 @@
 class Solution {
-    public static String[] uncommonFromSentences(String A, String B) {
-        Map<String, Long> map = Arrays.
-                                    stream((A + " " + B).
-                                    split("\\s+")).
-                                    collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
-
-        List<String> uncommon = map.
-                                    entrySet().
-                                    stream().
-                                    filter(e -> e.getValue() == 1).
-                                    map(e -> e.getKey()).
-                                    collect(Collectors.toList());
-
-        String[] ans = new String[uncommon.size()];
-
-        return uncommon.toArray(ans);
+  public String[] uncommonFromSentences(String s1, String s2) {
+    Map<String, Integer> map = new HashMap<>();
+    String[] wordsOne = s1.split("\\s+");
+    for (String word : wordsOne) {
+      map.put(word, map.getOrDefault(word, 0) + 1);
     }
+    String[] wordsTwo = s2.split("\\s+");
+    for (String word : wordsTwo) {
+      map.put(word, map.getOrDefault(word, 0) + 1);
+    }
+    List<String> result = new ArrayList<>();
+    for (String key : map.keySet()) {
+      if (map.get(key) == 1) {
+        result.add(key);
+      }
+    }
+    return result.toArray(new String[]{});
+  }
 }

From 2c015331641fcaf9c414ba9aee8f50845b18aa89 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 12:50:23 -0700
Subject: [PATCH 1015/2175] Update How Many Apples Can You Put into the
 Basket.java

---
 ...ny Apples Can You Put into the Basket.java | 22 ++++++++++++-------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/Easy/How Many Apples Can You Put into the Basket.java b/Easy/How Many Apples Can You Put into the Basket.java
index 4626ce53..5e6b8543 100644
--- a/Easy/How Many Apples Can You Put into the Basket.java	
+++ b/Easy/How Many Apples Can You Put into the Basket.java	
@@ -1,12 +1,18 @@
 class Solution {
-  public int maxNumberOfApples(int[] arr) {
-    int weight = 0;
-    int currCount = 0;
-    Arrays.sort(arr);
-    for (int i = 0; i < arr.length && weight + arr[i] <= 5000; i++) {
-      weight += arr[i];
-      currCount++;
+  public int maxNumberOfApples(int[] weight) {
+    int[] counter = new int[1001];
+    for (int w : weight) {
+      counter[w]++;
     }
-    return currCount;
+    int numberOfApples = 0;
+    int totalWeight = 0;
+    for (int i = 1; i < counter.length && totalWeight <= 5000; i++) {
+      int count = counter[i];
+      while (count-- > 0 && totalWeight + i <= 5000) {
+        numberOfApples++;
+        totalWeight += i;
+      }
+    }
+    return numberOfApples;
   }
 }

From 571393889e9bec48afb9a8fcf19a612624273d74 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 14:34:24 -0700
Subject: [PATCH 1016/2175] Update Reverse String II.java

---
 Easy/Reverse String II.java | 27 ++++++++-------------------
 1 file changed, 8 insertions(+), 19 deletions(-)

diff --git a/Easy/Reverse String II.java b/Easy/Reverse String II.java
index a2e13d9a..168f553d 100644
--- a/Easy/Reverse String II.java	
+++ b/Easy/Reverse String II.java	
@@ -1,26 +1,15 @@
 class Solution {
   public String reverseStr(String s, int k) {
+    boolean reverse = true;
     StringBuilder sb = new StringBuilder();
-    boolean current = true;
-    int idx = 0;
-    int n = s.length();
-    while (idx < n) {
-      int endIdx = Math.min(idx + k - 1, n - 1);
-      if (current) {
-        int end = idx;
-        int start = endIdx;
-        for (int i = start; i >= end; i--) {
-          sb.append(s.charAt(i));
-        }
-        idx = endIdx + 1;
+    for (int i = 0; i < s.length(); i += k) {
+      String substring = s.substring(i, Math.min(i + k, s.length()));
+      if (reverse) {
+        sb.append(new StringBuilder().append(substring).reverse().toString());
+      } else {
+        sb.append(substring);
       }
-      else {
-        while (idx <= endIdx) {
-          sb.append(s.charAt(idx++));
-        }
-      }
-      current = !current;
-      System.out.println(idx);
+      reverse = !reverse;
     }
     return sb.toString();
   }

From a887be56e2797d4cc3f3634ac66131d864a5c62a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 15:51:09 -0700
Subject: [PATCH 1017/2175] Update Two Sum IV - Input is a BST.java

---
 Easy/Two Sum IV - Input is a BST.java | 57 ++++++++++-----------------
 1 file changed, 20 insertions(+), 37 deletions(-)

diff --git a/Easy/Two Sum IV - Input is a BST.java b/Easy/Two Sum IV - Input is a BST.java
index 84f1f8cd..5f38ca2a 100644
--- a/Easy/Two Sum IV - Input is a BST.java	
+++ b/Easy/Two Sum IV - Input is a BST.java	
@@ -4,46 +4,29 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public boolean findTarget(TreeNode root, int k) {
-        Stack<TreeNode> stack = new Stack<>();
-        while (root != null) {
-            stack.push(root);
-            root = root.left;
-        }
-        
-        Set<Integer> set = new HashSet<>();
-        int min = popStack(stack);
-        set.add(min);
-        
-        while (!stack.isEmpty()) {
-            int num = popStack(stack);
-            if (set.contains(k-num)) {
-                return true;
-            }
-            
-            if (min + num > k) {
-                return false;
-            }
-            
-            set.add(num);
-        }
-        
-        return false;
+  public boolean findTarget(TreeNode root, int k) {
+    Set<Integer> set = new HashSet<>();
+    return helper(root, k, set);
+  }
+  
+  private boolean helper(TreeNode root, int k, Set<Integer> set) {
+    if (root == null) {
+      return false;
     }
-    
-    private int popStack(Stack<TreeNode> stack) {
-        TreeNode n = stack.pop();
-        TreeNode right = n.right;
-        
-        while (right != null) {
-            stack.push(right);
-            right = right.left;
-        }
-        
-        return n.val;
+    if (set.contains(k - root.val)) {
+      return true;
     }
+    set.add(root.val);
+    return helper(root.left, k, set) || helper(root.right, k, set);
+  }
 }

From 2fe07f9a9bb28a3494e122417021f21890a5c585 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 May 2022 15:51:54 -0700
Subject: [PATCH 1018/2175] Update Greatest Common Divisor of Strings.java

---
 Easy/Greatest Common Divisor of Strings.java | 43 +++++---------------
 1 file changed, 10 insertions(+), 33 deletions(-)

diff --git a/Easy/Greatest Common Divisor of Strings.java b/Easy/Greatest Common Divisor of Strings.java
index 3a08a29f..263b6caa 100644
--- a/Easy/Greatest Common Divisor of Strings.java	
+++ b/Easy/Greatest Common Divisor of Strings.java	
@@ -1,36 +1,13 @@
 class Solution {
-    public String gcdOfStrings(String str1, String str2) {
-        return stringGcd(str1, str2);
-    }
-    
-    private String stringGcd(String s1, String s2) {
-        if (s1.length() == 0) {
-            return s2;
-        }
-        
-        if (s2.length() == 0) {
-            return s1;
-        }
-        
-        if (s1.equals(s2)) {
-            return s1;
-        }
-        
-        if (s1.length() > s2.length()) {
-            for (int i = 0; i < s2.length(); i++) {
-                if (s1.charAt(i) != s2.charAt(i)) {
-                    return "";
-                }
-            }
-            
-            String temp = s1.substring(s2.length());
-            return stringGcd(temp, s2);
-        }
-        
-        if (s2.length() > s1.length()) {
-            return stringGcd(s2, s1);
-        }
-        
-        return "";
+  public String gcdOfStrings(String str1, String str2) {
+    if (str1.length() < str2.length()) {  
+      return gcdOfStrings(str2, str1); 
+    } else if (!str1.startsWith(str2)) {
+      return "";
+    } else if (str2.isEmpty()) { 
+      return str1;
+    } else { 
+      return gcdOfStrings(str1.substring(str2.length()), str2); 
     }
+  }
 }

From 777a467d2c2c71d297ba342ddadcb4794fccba2e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 27 May 2022 18:01:08 -0700
Subject: [PATCH 1019/2175] Update Missing Number.java

---
 Easy/Missing Number.java | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/Easy/Missing Number.java b/Easy/Missing Number.java
index 5e9021db..5d737295 100644
--- a/Easy/Missing Number.java	
+++ b/Easy/Missing Number.java	
@@ -1,6 +1,11 @@
 class Solution {
   public int missingNumber(int[] nums) {
-    return (nums.length * (nums.length + 1) / 2) - Arrays.stream(nums).boxed()
-        .reduce(0, Integer::sum);
+    int totalSum = 0;
+    for (int num : nums) {
+      totalSum += num;
+    }
+    int n = nums.length;
+    int expectedSum = (n * (n + 1)) / 2;
+    return expectedSum - totalSum;
   }
 }

From b82b111a4c7c9aba534083dddc847023ccf93e37 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 29 May 2022 06:41:57 -0700
Subject: [PATCH 1020/2175] Create Maximum Product of Word Lengths.java

---
 Medium/Maximum Product of Word Lengths.java | 25 +++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Maximum Product of Word Lengths.java

diff --git a/Medium/Maximum Product of Word Lengths.java b/Medium/Maximum Product of Word Lengths.java
new file mode 100644
index 00000000..d98a03bb
--- /dev/null
+++ b/Medium/Maximum Product of Word Lengths.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int maxProduct(String[] words) {
+    int maxProd = 0;
+    for (int i = 0; i < words.length; i++) {
+      for (int j = i + 1; j < words.length; j++) {
+        if (noCommonLetters(words[i], words[j])) {
+          maxProd = Math.max(maxProd, words[i].length() * words[j].length());
+        }
+      }
+    }
+    return maxProd;
+  }
+  
+  private boolean noCommonLetters(String s1, String s2) {
+    int bitMaskOne = 0;
+    int bitMaskTwo = 0;
+    for (char c : s1.toCharArray()) {
+      bitMaskOne |= 1 << ((int) c - (int) 'a');
+    }
+    for (char c : s2.toCharArray()) {
+      bitMaskTwo |= 1 << ((int) c - (int) 'a');
+    }
+    return (bitMaskOne & bitMaskTwo) == 0;
+  }
+}

From 88af1c286e48261f972c6345ac823221b2315769 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 29 May 2022 06:50:53 -0700
Subject: [PATCH 1021/2175] Create Rearrange Characters to Make Target
 String.java

---
 ...rrange Characters to Make Target String.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Rearrange Characters to Make Target String.java

diff --git a/Easy/Rearrange Characters to Make Target String.java b/Easy/Rearrange Characters to Make Target String.java
new file mode 100644
index 00000000..352e45f9
--- /dev/null
+++ b/Easy/Rearrange Characters to Make Target String.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int rearrangeCharacters(String s, String target) {
+    int[] frequencyS = new int[26];
+    int[] frequencyTarget = new int[26];
+    for(char ch : s.toCharArray()) {
+      frequencyS[ch-'a']++;
+    }
+    for(char ch : target.toCharArray()) {
+      frequencyTarget[ch-'a']++;
+    }
+    int maxCopies = Integer.MAX_VALUE;
+    for(char ch : target.toCharArray()) {
+      maxCopies = Math.min(maxCopies, frequencyS[ch - 'a'] / frequencyTarget[ch - 'a']);
+    }
+    return maxCopies;
+  }
+}

From 75eef622be9a4beb92b5d0cf7c11770256fccfe6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 29 May 2022 06:56:26 -0700
Subject: [PATCH 1022/2175] Create Check if Number Has Equal Digit Count and
 Digit Value.java

---
 ...er Has Equal Digit Count and Digit Value.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Check if Number Has Equal Digit Count and Digit Value.java

diff --git a/Easy/Check if Number Has Equal Digit Count and Digit Value.java b/Easy/Check if Number Has Equal Digit Count and Digit Value.java
new file mode 100644
index 00000000..8ea9bbc7
--- /dev/null
+++ b/Easy/Check if Number Has Equal Digit Count and Digit Value.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public boolean digitCount(String num) {
+    int[] frequency = new int[10];
+    for (char c : num.toCharArray()) {
+      frequency[Character.getNumericValue(c)]++;
+    }
+    for (int i = 0; i < num.length(); i++) {
+      int digit = i;
+      int expectedFrequency = Character.getNumericValue(num.charAt(i));
+      if (frequency[digit] != expectedFrequency) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

From fcc7e332f353979ff83e3ddc64bfbbe3e9e71588 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 31 May 2022 15:30:29 -0700
Subject: [PATCH 1023/2175] Update Valid Parentheses.java

---
 Easy/Valid Parentheses.java | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/Easy/Valid Parentheses.java b/Easy/Valid Parentheses.java
index 911e52a5..da0a68f1 100644
--- a/Easy/Valid Parentheses.java	
+++ b/Easy/Valid Parentheses.java	
@@ -1,20 +1,17 @@
 class Solution {
   public boolean isValid(String s) {
-    Stack<Character> stack = new Stack<>();
+    Deque<Character> stack = new ArrayDeque<>();
     for (char c : s.toCharArray()) {
-      if (c == '[' || c == '{' || c == '(') {
-        stack.push(c);
+      if (c == '(' || c == '[' || c == '{') {
+        stack.add(c);
       } else {
         if (stack.isEmpty()) {
           return false;
         }
-        char popped = stack.pop();
-        if ((c == ')' && popped == '(') || 
-            (c == ']' && popped == '[') ||
-            (c == '}' && popped == '{')) {
-          continue;
+        char popped = stack.removeLast();
+        if (!((c == ')' && popped == '(') || (c == ']' && popped == '[') || (c == '}' && popped == '{'))) {
+          return false;
         }
-        return false;
       }
     }
     return stack.isEmpty();

From 0a51c4ab8bd0c8e624cdb01c7588999da8ae8e25 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Jun 2022 09:58:27 -0700
Subject: [PATCH 1024/2175] Update Running Sum of 1d Array.java

---
 Easy/Running Sum of 1d Array.java | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Easy/Running Sum of 1d Array.java b/Easy/Running Sum of 1d Array.java
index a724f9d9..bc5f422a 100644
--- a/Easy/Running Sum of 1d Array.java	
+++ b/Easy/Running Sum of 1d Array.java	
@@ -1,9 +1,10 @@
 class Solution {
   public int[] runningSum(int[] nums) {
-    int[] ans = new int[nums.length];
+    int sum = 0;
     for (int i = 0; i < nums.length; i++) {
-      ans[i] = nums[i] + (i == 0 ? 0 : ans[i - 1]);
+      sum += nums[i];
+      nums[i] = sum;
     }
-    return ans;
+    return nums;
   }
 }

From 8f79499bce09caad0d13c23acea17621ab64058f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Jun 2022 19:05:38 -0700
Subject: [PATCH 1025/2175] Update Transpose Matrix.java

---
 Easy/Transpose Matrix.java | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/Easy/Transpose Matrix.java b/Easy/Transpose Matrix.java
index f59cb99f..996dd16f 100644
--- a/Easy/Transpose Matrix.java	
+++ b/Easy/Transpose Matrix.java	
@@ -1,14 +1,13 @@
 class Solution {
-  public int[][] transpose(int[][] A) {
-    if (A.length == 0 || A[0].length == 0) {
-      return A;
-    }
-    int[][] ans = new int[A[0].length][A.length];
-    for (int i = 0; i < A[0].length; i++) {
-      for (int j = 0; j < A.length; j++) {
-        ans[i][j] = A[j][i];
+  public int[][] transpose(int[][] matrix) {
+    int rows = matrix.length;
+    int cols = matrix[0].length;
+    int[][] result = new int[cols][rows];
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        result[j][i] = matrix[i][j];
       }
     }
-    return ans;
+    return result;
   }
 }

From 3b0dfd28e69dfba250bccfed29f34a912661c0ea Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Jun 2022 19:11:37 -0700
Subject: [PATCH 1026/2175] Create Sender With Largest Word Count.java

---
 Medium/Sender With Largest Word Count.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Sender With Largest Word Count.java

diff --git a/Medium/Sender With Largest Word Count.java b/Medium/Sender With Largest Word Count.java
new file mode 100644
index 00000000..6bb1bf25
--- /dev/null
+++ b/Medium/Sender With Largest Word Count.java	
@@ -0,0 +1,22 @@
+import java.util.Map.Entry;
+
+
+class Solution {
+  public String largestWordCount(String[] messages, String[] senders) {
+    Map<String, Integer> map = new HashMap<>();
+    for (int i = 0; i < messages.length; i++) {
+      int wordCount = messages[i].split("\\s+").length;
+      map.put(senders[i], map.getOrDefault(senders[i], 0) + wordCount);
+    }
+    return map.entrySet().stream()
+        .sorted((o1, o2) -> {
+          int c = o2.getValue() - o1.getValue();
+          if (c != 0) {
+            return c;
+          }
+          return o2.getKey().compareTo(o1.getKey());})
+        .map(Entry::getKey)
+        .findFirst()
+        .orElse("");
+  }
+}

From f4ac6795bf9de5d0ccac64951457072522431778 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Jun 2022 19:31:15 -0700
Subject: [PATCH 1027/2175] Create Apply Discount to Prices.java

---
 Medium/Apply Discount to Prices.java | 48 ++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 Medium/Apply Discount to Prices.java

diff --git a/Medium/Apply Discount to Prices.java b/Medium/Apply Discount to Prices.java
new file mode 100644
index 00000000..6c3974c9
--- /dev/null
+++ b/Medium/Apply Discount to Prices.java	
@@ -0,0 +1,48 @@
+class Solution {
+  public String discountPrices(String sentence, int discount) {
+    StringBuilder sb = new StringBuilder();
+    int idx = 0;
+    int n = sentence.length();
+    while (idx < n) {
+      if (sentence.charAt(idx) == '$') {
+        if (idx == 0 || sentence.charAt(idx - 1) == ' ') {
+          sb.append(sentence.charAt(idx++));
+          StringBuilder possibleDigit = new StringBuilder();
+          boolean isDigit = true;
+          while (idx < n && sentence.charAt(idx) != ' ') {
+            if (!Character.isDigit(sentence.charAt(idx))) {
+              isDigit = false;
+            }
+            possibleDigit.append(sentence.charAt(idx++));
+          }
+          if (possibleDigit.length() == 0) {
+            continue;
+          }
+          if (isDigit) {
+            long price = Long.parseLong(possibleDigit.toString());
+            long updatedPrice = price * (100 - discount);
+            sb.append(getFormattedPrice(updatedPrice));
+          } else {
+            sb.append(possibleDigit);
+          }
+        } else {
+          sb.append(sentence.charAt(idx++));
+        }
+      } else {
+        sb.append(sentence.charAt(idx++));
+      }
+    }
+    return sb.toString();
+  }
+  
+  private String getFormattedPrice(long price) {
+    if (price < 10) {
+      return "0.0" + price;
+    } else if (price < 100) {
+      return "0." + price;
+    } else {
+      String priceString = String.valueOf(price);
+      return priceString.substring(0, priceString.length() - 2) + "." + priceString.substring(priceString.length() - 2);
+    }
+  }
+}

From 7ee88c3075731cf57b4a7d5d3b78e7243c7a7658 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 2 Jun 2022 14:59:10 -0700
Subject: [PATCH 1028/2175] Update Minimum Knight Moves.java

---
 Medium/Minimum Knight Moves.java | 30 +++++++++++-------------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/Medium/Minimum Knight Moves.java b/Medium/Minimum Knight Moves.java
index 94d27fbe..e1352ac4 100644
--- a/Medium/Minimum Knight Moves.java	
+++ b/Medium/Minimum Knight Moves.java	
@@ -1,36 +1,28 @@
 class Solution {
-  public final int[][] DIRS = {{2, 1}, {1, 2}, {-1, 2}, {-2, 1}, {-2, -1}, {-1, -2}, {1, -2}, {2, -1}};
+  private final int[][] DIRS = {{1, 2}, {2, 1}, {1, -2}, {-2, 1}, {2, -1}, {-2, -1}, {-1, -2}, {-1, 2}};
+  
   public int minKnightMoves(int x, int y) {
-    int currX = 0;
-    int currY = 0;
-    int targetX = Math.abs(x);
-    int targetY = Math.abs(y);
-    Set<String> visited = new HashSet<>();
-    Queue<int[]> queue = new LinkedList<>();
     int numOfSteps = 0;
-    visited.add(currX + "|" + currY);
-    queue.add(new int[]{currX, currY});
+    boolean[][] visited = new boolean[607][607];
+    Queue<int[]> queue = new LinkedList<>();
+    queue.add(new int[]{0, 0});
     while (!queue.isEmpty()) {
       int size = queue.size();
-      boolean found = false;
       while (size-- > 0) {
         int[] removed = queue.remove();
-        if (removed[0] == targetX && removed[1] == targetY) {
-          found = true;
-          break;
+        if (removed[0] == x && removed[1] == y) {
+          return numOfSteps;
         }
         for (int[] dir : DIRS) {
           int newX = removed[0] + dir[0];
           int newY = removed[1] + dir[1];
-          if (!visited.contains(newX + "|" + newY) && newX >= -1 && newY >= -1) {
-            visited.add(newX + "|" + newY);
-            queue.add(new int[]{newX, newY});
+          if (visited[newX + 302][newY + 302]) {
+            continue;
           }
+          visited[newX + 302][newY + 302] = true;
+          queue.add(new int[]{newX, newY});
         }
       }
-      if (found) {
-        break;
-      }
       numOfSteps++;
     }
     return numOfSteps;

From 98863f108159c671fffffb570ad63adee834bb31 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 2 Jun 2022 15:19:50 -0700
Subject: [PATCH 1029/2175] Create Maximum Total Importance of Roads.java

---
 Medium/Maximum Total Importance of Roads.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Maximum Total Importance of Roads.java

diff --git a/Medium/Maximum Total Importance of Roads.java b/Medium/Maximum Total Importance of Roads.java
new file mode 100644
index 00000000..52e5eea7
--- /dev/null
+++ b/Medium/Maximum Total Importance of Roads.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public long maximumImportance(int n, int[][] roads) {
+    int[] outDegree = new int[n];
+    for (int[] road : roads) {
+      outDegree[road[0]]++;
+      outDegree[road[1]]++;
+    }
+    Arrays.sort(outDegree);
+    long totalImportance = 0;
+    long importanceMultiple = 1L;
+    for (int count : outDegree) {
+      totalImportance += importanceMultiple * count;
+      importanceMultiple++;
+    }
+    return totalImportance;
+  }
+}

From 7839237825b95e83f64bd7762179fb37f97e6535 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 3 Jun 2022 07:15:49 -0700
Subject: [PATCH 1030/2175] Update Range Sum Query 2D-Immutable.java

---
 Medium/Range Sum Query 2D-Immutable.java | 27 +++++++++++++++---------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/Medium/Range Sum Query 2D-Immutable.java b/Medium/Range Sum Query 2D-Immutable.java
index 9139dcef..bd30c3e1 100644
--- a/Medium/Range Sum Query 2D-Immutable.java	
+++ b/Medium/Range Sum Query 2D-Immutable.java	
@@ -1,21 +1,28 @@
 class NumMatrix {
-  int[][] dp;
+
+  int rows;
+  int cols;
+  int[][] rowLevelSum;
   public NumMatrix(int[][] matrix) {
-    if (matrix.length == 0 || matrix[0].length == 0) {
-      return;
-    }
-    dp = new int[matrix.length][matrix[0].length + 1];
-    for (int i = 0; i < matrix.length; i++) {
-      for (int j = 0; j < matrix[0].length; j++) {
-        dp[i][j + 1] = dp[i][j] + matrix[i][j];
+    this.rows = matrix.length;
+    this.cols = matrix[0].length;
+    this.rowLevelSum = new int[rows][cols];
+    for (int i = 0; i < rows; i++) {
+      int sum = 0;
+      for (int j = 0; j < cols; j++) {
+        sum += matrix[i][j];
+        this.rowLevelSum[i][j] = sum;
       }
     }
   }
 
   public int sumRegion(int row1, int col1, int row2, int col2) {
     int sum = 0;
-    for (int row = row1; row <= row2; row++) {
-      sum += dp[row][col2 + 1] - dp[row][col1];
+    for (int i = row1; i <= row2; i++) {
+      sum += rowLevelSum[i][col2];
+      if (col1 > 0) {
+        sum -= rowLevelSum[i][col1 - 1];
+      }
     }
     return sum;
   }

From bf5a9513c33501479883e8b0af84ea58fb0690e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 3 Jun 2022 07:51:37 -0700
Subject: [PATCH 1031/2175] Update Number of Equivalent Domino Pairs.java

---
 Easy/Number of Equivalent Domino Pairs.java | 25 ++++++---------------
 1 file changed, 7 insertions(+), 18 deletions(-)

diff --git a/Easy/Number of Equivalent Domino Pairs.java b/Easy/Number of Equivalent Domino Pairs.java
index 718169ae..422b51e2 100644
--- a/Easy/Number of Equivalent Domino Pairs.java	
+++ b/Easy/Number of Equivalent Domino Pairs.java	
@@ -1,23 +1,12 @@
 class Solution {
   public int numEquivDominoPairs(int[][] dominoes) {
-    int count = 0;
-    Map<String, Integer> map = new HashMap<>();
-    for (int i = 0; i < dominoes.length; i++) {
-      String straightKey = dominoes[i][0] + "/" + dominoes[i][1];
-      String revKey = dominoes[i][1] + "/" + dominoes[i][0];
-      if (map.containsKey(straightKey)) {
-        count += map.get(straightKey);
-      }
-      else if (!straightKey.equals(revKey)) {
-        if (map.containsKey(revKey)) {
-          count += map.get(revKey);
-        }
-      }
-      map.put(straightKey, map.getOrDefault(straightKey, 0) + 1);
-      if (dominoes[i][0] != dominoes[i][1]) {
-        map.put(revKey, map.getOrDefault(revKey, 0) + 1);
-      }
+    int numOfPairs = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int[] dominoe : dominoes) {
+      int key = Math.min(dominoe[0], dominoe[1]) * 10 + Math.max(dominoe[0], dominoe[1]);
+      numOfPairs += map.getOrDefault(key, 0);
+      map.put(key, map.getOrDefault(key, 0) + 1);
     }
-    return count;
+    return numOfPairs;
   }
 }

From 190ad7eacef08166a2bd24d46ab633bbd736c08e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 3 Jun 2022 16:00:23 -0700
Subject: [PATCH 1032/2175] Update Find All Numbers Disappeared in an
 Array.java

---
 ...Find All Numbers Disappeared in an Array.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Easy/Find All Numbers Disappeared in an Array.java b/Easy/Find All Numbers Disappeared in an Array.java
index 4e3865b9..4cab6c67 100644
--- a/Easy/Find All Numbers Disappeared in an Array.java	
+++ b/Easy/Find All Numbers Disappeared in an Array.java	
@@ -1,17 +1,17 @@
 class Solution {
   public List<Integer> findDisappearedNumbers(int[] nums) {
+    List<Integer> result = new ArrayList<>();
     for (int i = 0; i < nums.length; i++) {
-      int newIdx = Math.abs(nums[i]) - 1;
-      if (nums[newIdx] > 0) {
-        nums[newIdx] *= -1;
+      int idx = Math.abs(nums[i]) - 1;
+      if (nums[idx] > 0) {
+        nums[idx] *= -1;
       }
     }
-    List<Integer> list = new ArrayList<>();
-    for (int i = 1; i <= nums.length; i++) {
-      if (nums[i - 1] > 0) {
-        list.add(i);
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] > 0) {
+        result.add(i + 1);
       }
     }
-    return list;
+    return result;
   }
 }

From bf0fca1f4eacbb5af99badc54dc9046f2322b311 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 4 Jun 2022 08:39:22 -0700
Subject: [PATCH 1033/2175] Update N-Queens.java

---
 Hard/N-Queens.java | 71 +++++++++++++++++++++-------------------------
 1 file changed, 33 insertions(+), 38 deletions(-)

diff --git a/Hard/N-Queens.java b/Hard/N-Queens.java
index 2e382180..0551c884 100644
--- a/Hard/N-Queens.java
+++ b/Hard/N-Queens.java
@@ -1,50 +1,45 @@
 class Solution {
   public List<List<String>> solveNQueens(int n) {
-    List<List<String>> ans = new ArrayList <>();
-    helper(n, 0, new ArrayList<>(), ans);
-    return ans;
+    List<List<String>> result = new ArrayList<>();
+    char[][] board = new char[n][n];
+    for (char[] row : board) {
+      Arrays.fill(row, '.');
+    }
+    backtrack(0, new HashSet<>(), new HashSet<>(), new HashSet<>(), board, result, n);
+    return result;
   }
-
-  private void helper(int n, int row, List<Integer> selections, List<List<String>> ans) {
+  
+  private void backtrack(int row, Set<Integer> diagonals, Set<Integer> antiDiagonals, Set<Integer> columns, char[][] board, List<List<String>> result, int n) {
     if (row == n) {
-      ans.add(convertToString(selections, n));
+      result.add(buildBoard(board, n));
+      return;
     }
-    else {
-      for (int i = 0; i < n; i++) {
-        selections.add(i);
-        if (isValid(selections)) {
-          helper(n, row + 1, selections, ans);
-        }
-        selections.remove(selections.size() - 1);
+    for (int col = 0; col < n; col++) {
+      int currDiagonal = row - col;
+      int currAntiDiagonal = row + col;
+      if (columns.contains(col) || diagonals.contains(currDiagonal) || antiDiagonals.contains(currAntiDiagonal)) {
+        continue;
       }
-    }
-  }
+      columns.add(col);
+      diagonals.add(currDiagonal);
+      antiDiagonals.add(currAntiDiagonal);
+      board[row][col] = 'Q';
 
-  private List <String> convertToString(List <Integer> selections, int n) {
-    List<String> ret = new ArrayList<>();
-    for (int i = 0; i < selections.size(); i++) {
-      StringBuilder sb = new StringBuilder();
-      for (int j = 0; j < n; j++) {
-        if (j == selections.get(i)) {
-          sb.append("Q");
-        }
-        else {
-          sb.append(".");
-        }
-      }
-      ret.add(sb.toString());
+      backtrack(row + 1, diagonals, antiDiagonals, columns, board, result, n);
+      
+      columns.remove(col);
+      diagonals.remove(currDiagonal);
+      antiDiagonals.remove(currAntiDiagonal);
+      board[row][col] = '.';
     }
-    return ret;
   }
-
-  private boolean isValid(List <Integer> selections) {
-    int row = selections.size() - 1;
-    for (int i = 0; i < row; i++) {
-      int diff = Math.abs(selections.get(i) - selections.get(row));
-      if (diff == 0 || diff == row - i) {
-        return false;
-      }
+  
+  private List<String> buildBoard(char[][] board, int n) {
+    List<String> resultBoard = new ArrayList<>();
+    for (int row = 0; row < n; row++) {
+      String currentRow = new String(board[row]);
+      resultBoard.add(currentRow);
     }
-    return true;
+    return resultBoard;
   }
 }

From 5aeda12919900db6d2b9f278be09c566326378a3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 4 Jun 2022 18:37:46 -0700
Subject: [PATCH 1034/2175] Create N-Queens II.java

---
 Hard/N-Queens II.java | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Hard/N-Queens II.java

diff --git a/Hard/N-Queens II.java b/Hard/N-Queens II.java
new file mode 100644
index 00000000..0cc14059
--- /dev/null
+++ b/Hard/N-Queens II.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int totalNQueens(int n) {
+    return backtrack(0, new HashSet<>(), new HashSet<>(), new HashSet<>(), n);
+  }
+  
+  private int backtrack(int row, Set<Integer> diagonals, Set<Integer> antiDiagonals, Set<Integer> columns, int n) {
+    if (row == n) {
+      return 1;
+    }
+    int possibleSolutions = 0;
+    for (int col = 0; col < n; col++) {
+      int currDiagonal = row - col;
+      int currAntiDiagonal = row + col;
+      if (columns.contains(col) || diagonals.contains(currDiagonal) || antiDiagonals.contains(currAntiDiagonal)) {
+        continue;
+      }
+      columns.add(col);
+      diagonals.add(currDiagonal);
+      antiDiagonals.add(currAntiDiagonal);
+
+      possibleSolutions += backtrack(row + 1, diagonals, antiDiagonals, columns, n);
+      
+      columns.remove(col);
+      diagonals.remove(currDiagonal);
+      antiDiagonals.remove(currAntiDiagonal);
+    }
+    return possibleSolutions;
+  }
+}

From 5da9421f25fda2aa9d744c2f31b3189a16336cc8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 Jun 2022 10:57:36 -0700
Subject: [PATCH 1035/2175] Create Min Max Game.java

---
 Easy/Min Max Game.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Min Max Game.java

diff --git a/Easy/Min Max Game.java b/Easy/Min Max Game.java
new file mode 100644
index 00000000..f2405c20
--- /dev/null
+++ b/Easy/Min Max Game.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int minMaxGame(int[] nums) {
+    Queue<Integer> queue = new LinkedList<>();
+    for (int num : nums) {
+      queue.add(num);
+    }
+    while (queue.size() > 1) {
+      int size = queue.size();
+      boolean even = true;
+      for (int i = 0; i < size; i += 2) {
+        if (even) {
+          queue.add(Math.min(queue.remove(), queue.remove()));
+        } else {
+          queue.add(Math.max(queue.remove(), queue.remove()));
+        }
+        even = !even;
+      }
+    }
+    return queue.remove();
+  }
+}

From 835a30a0429869173f7fcfefaaa45b8457e1385d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 Jun 2022 11:05:17 -0700
Subject: [PATCH 1036/2175] Create Replace Elements in an Array.java

---
 Medium/Replace Elements in an Array.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Replace Elements in an Array.java

diff --git a/Medium/Replace Elements in an Array.java b/Medium/Replace Elements in an Array.java
new file mode 100644
index 00000000..77140194
--- /dev/null
+++ b/Medium/Replace Elements in an Array.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int[] arrayChange(int[] nums, int[][] operations) {
+    Map<Integer, Integer> indexMap = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+      indexMap.put(nums[i], i);
+    }
+    for (int[] operation : operations) {
+      int prevElementIdx = indexMap.get(operation[0]);
+      indexMap.put(operation[1], prevElementIdx);
+      nums[prevElementIdx] = operation[1];
+    }
+    return nums;
+  }
+}

From ffd93c31f316b95089052026712b4bf63ddce292 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Jun 2022 07:10:39 -0700
Subject: [PATCH 1037/2175] Update Intersection of two Linked Lists.java

---
 Easy/Intersection of two Linked Lists.java | 38 ++++------------------
 1 file changed, 6 insertions(+), 32 deletions(-)

diff --git a/Easy/Intersection of two Linked Lists.java b/Easy/Intersection of two Linked Lists.java
index f515b847..2da135fb 100644
--- a/Easy/Intersection of two Linked Lists.java	
+++ b/Easy/Intersection of two Linked Lists.java	
@@ -11,38 +11,12 @@
  */
 public class Solution {
   public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
-    int lenA = getLength(headA);
-    int lenB = getLength(headB);
-    ListNode currA = headA;
-    ListNode currB = headB;
-    if (lenA > lenB) {
-      int diff = lenA - lenB;
-      while (diff-- > 0) {
-        currA = currA.next;
-      }
+    ListNode copyA = headA;
+    ListNode copyB = headB;
+    while (copyA != copyB) {
+      copyA = copyA == null ? headB : copyA.next;
+      copyB = copyB == null ? headA : copyB.next;
     }
-    if (lenB > lenA) {
-      int diff = lenB - lenA;
-      while (diff-- > 0) {
-        currB = currB.next;
-      }
-    }
-    while (currA != null && currB != null) {
-      if (currA == currB) {
-        return currA;
-      }
-      currA = currA.next;
-      currB = currB.next;
-    }
-    return null;
-  }
-  
-  private int getLength(ListNode node) {
-    int len = 0;
-    while (node != null) {
-      node = node.next;
-      len++;
-    }
-    return len;
+    return copyA;
   }
 }

From c10eed376c9d7e4bed98fe1a2d80af3ddba1db4d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Jun 2022 08:02:21 -0700
Subject: [PATCH 1038/2175] Update and rename Easy/Count and Say.java to
 Medium/Count and Say.java

---
 Easy/Count and Say.java   | 23 -----------------------
 Medium/Count and Say.java | 19 +++++++++++++++++++
 2 files changed, 19 insertions(+), 23 deletions(-)
 delete mode 100644 Easy/Count and Say.java
 create mode 100644 Medium/Count and Say.java

diff --git a/Easy/Count and Say.java b/Easy/Count and Say.java
deleted file mode 100644
index 7f2eed96..00000000
--- a/Easy/Count and Say.java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class Solution {
-  public String countAndSay(int n) {
-    return rec(n, "1");
-  }
-  
-  private String rec(int n, String s) {
-    if (n == 1) {
-      return s;
-    }
-    StringBuilder sb = new StringBuilder();
-    int idx = 0;
-    while (idx < s.length()) {
-      char c = s.charAt(idx);
-      int count = 0;
-      while (idx < s.length() && s.charAt(idx) == c) {
-        idx++;
-        count++;
-      }
-      sb.append(count).append(c);
-    }
-    return rec(n - 1, sb.toString());
-  }
-}
diff --git a/Medium/Count and Say.java b/Medium/Count and Say.java
new file mode 100644
index 00000000..a32318be
--- /dev/null
+++ b/Medium/Count and Say.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public String countAndSay(int n) {
+    String s = "1";
+    for (int i = 1; i < n; i++) {
+      StringBuilder sb = new StringBuilder();
+      for (int j = 1, count = 1; j <= s.length(); j++) {
+        if (j == s.length() || s.charAt(j - 1) != s.charAt(j)) {
+          sb.append(count);
+          sb.append(s.charAt(j - 1));
+          count = 1;
+        } else {
+          count++;
+        }
+      }
+      s = sb.toString();
+    }
+    return s;
+  }
+}

From d46093df1fae35def2d6652e0247d9a6dbac17df Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Jun 2022 09:42:08 -0700
Subject: [PATCH 1039/2175] Update Two Sum BSTs.java

---
 Medium/Two Sum BSTs.java | 40 ++++++++++++++++------------------------
 1 file changed, 16 insertions(+), 24 deletions(-)

diff --git a/Medium/Two Sum BSTs.java b/Medium/Two Sum BSTs.java
index 1a796d58..d6dd2cf3 100644
--- a/Medium/Two Sum BSTs.java	
+++ b/Medium/Two Sum BSTs.java	
@@ -15,35 +15,27 @@
  */
 class Solution {
   public boolean twoSumBSTs(TreeNode root1, TreeNode root2, int target) {
-    if (root1 == null || root2 == null) {
-      return false;
-    }
+    ArrayDeque<TreeNode> stack = new ArrayDeque<>();
     Set<Integer> set = new HashSet<>();
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root2);
-    while (!queue.isEmpty()) {
-      TreeNode removed = queue.remove();
-      set.add(removed.val);
-      if (removed.left != null) {
-        queue.add(removed.left);
-      }
-      if (removed.right != null) {
-        queue.add(removed.right);
+    while (!stack.isEmpty() || root1 != null) {
+      while (root1 != null) {
+        stack.push(root1);
+        root1 = root1.left;
       }
+      root1 = stack.pop();
+      set.add(target - root1.val);
+      root1 = root1.right;
     }
-    queue = new LinkedList<>();
-    queue.add(root1);
-    while (!queue.isEmpty()) {
-      TreeNode removed = queue.remove();
-      if (set.contains(target - removed.val)) {
-        return true;
+    while (!stack.isEmpty() || root2 != null) {
+      while (root2 != null) {
+        stack.push(root2);
+        root2 = root2.left;
       }
-      if (removed.left != null) {
-        queue.add(removed.left);
-      }
-      if (removed.right != null) {
-        queue.add(removed.right);
+      root2 = stack.pop();
+      if (set.contains(root2.val)) {
+        return true;
       }
+      root2 = root2.right;
     }
     return false;
   }

From b07f32df3974d96494cf2de252a20cd7e682a78b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Jun 2022 09:43:04 -0700
Subject: [PATCH 1040/2175] Update Rank Transform of an Array.java

---
 Easy/Rank Transform of an Array.java | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/Easy/Rank Transform of an Array.java b/Easy/Rank Transform of an Array.java
index 951115ae..401c317b 100644
--- a/Easy/Rank Transform of an Array.java	
+++ b/Easy/Rank Transform of an Array.java	
@@ -1,20 +1,20 @@
 class Solution {
   public int[] arrayRankTransform(int[] arr) {
-    PriorityQueue<Integer> pq = Arrays.stream(arr).boxed()
-        .collect(Collectors.toCollection(PriorityQueue::new));
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    for (int num : arr) {
+      pq.add(num);
+    }
     int rank = 1;
-    Map<Integer, Integer> rankMap = new HashMap<>();
+    Map<Integer, Integer> map = new HashMap<>();
     while (!pq.isEmpty()) {
-      int key = pq.poll();
-      rankMap.put(key, rank++);
-      while (!pq.isEmpty() && pq.peek() == key) {
-        pq.poll();
+      int removed = pq.poll();
+      if (!map.containsKey(removed)) {
+        map.put(removed, rank++);
       }
     }
-    int[] ans = new int[arr.length];
     for (int i = 0; i < arr.length; i++) {
-      ans[i] = rankMap.get(arr[i]);
+      arr[i] = map.get(arr[i]);
     }
-    return ans;
+    return arr;
   }
 }

From 1f62fb365709dfc7f75978ef60799923a957195d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Jun 2022 15:10:37 -0700
Subject: [PATCH 1041/2175] Update Relative Sort Array.java

---
 Easy/Relative Sort Array.java | 35 ++++++++++++-----------------------
 1 file changed, 12 insertions(+), 23 deletions(-)

diff --git a/Easy/Relative Sort Array.java b/Easy/Relative Sort Array.java
index 886b0c71..efee0153 100644
--- a/Easy/Relative Sort Array.java	
+++ b/Easy/Relative Sort Array.java	
@@ -1,32 +1,21 @@
 class Solution {
   public int[] relativeSortArray(int[] arr1, int[] arr2) {
-    Map<Integer, Integer> map = new HashMap<>();
-    for (int i = 0; i < arr2.length; i++) {
-      map.put(arr2[i], i);
-    }
-    PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
-      public int compare(Integer o1, Integer o2) {
-        return map.get(o1) - map.get(o2);
-      }
-    });
-    List<Integer> notPresent = new ArrayList<>();
+    int[] frequency = new int[1001];
     for (int num : arr1) {
-      if (map.containsKey(num)) {
-        pq.add(num);
-      }
-      else {
-        notPresent.add(num);
-      }
+      frequency[num]++;
     }
-    int[] ans = new int[arr1.length];
+    int[] result = new int[arr1.length];
     int idx = 0;
-    while (!pq.isEmpty()) {
-      ans[idx++] = pq.poll();
+    for (int num : arr2) {
+      while (frequency[num]-- > 0) {
+        result[idx++] = num;
+      }
     }
-    Collections.sort(notPresent);
-    for (int num : notPresent) {
-      ans[idx++] = num;
+    for (int i = 0; i < 1001; i++) {
+      while (frequency[i]-- > 0) {
+        result[idx++] = i;
+      }
     }
-    return ans;
+    return result;
   }
 }

From a996e3bb9c1bdfd35a93fc206c289c0498ba2595 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Jun 2022 15:23:19 -0700
Subject: [PATCH 1042/2175] Update Find N Unique Integers Sum up to Zero.java

---
 ...Find N Unique Integers Sum up to Zero.java | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/Easy/Find N Unique Integers Sum up to Zero.java b/Easy/Find N Unique Integers Sum up to Zero.java
index 3eb3d777..1b1de933 100644
--- a/Easy/Find N Unique Integers Sum up to Zero.java	
+++ b/Easy/Find N Unique Integers Sum up to Zero.java	
@@ -1,20 +1,17 @@
 class Solution {
   public int[] sumZero(int n) {
-    int[] arr = new int[n];
+    int[] result = new int[n];
     int idx = 0;
-    int num = n / 2;
-    while (idx < n / 2) {
-      arr[idx++] = num * -1;
-      num--;
+    int half = n / 2;
+    for (int i = -1 * half; i < 0; i++) {
+      result[idx++] = i;
     }
     if (n % 2 != 0) {
-      arr[idx++] = 0;
+      result[idx++] = 0;
     }
-    num = n / 2;
-    while (idx < n) {
-      arr[idx++] = num;
-      num--;
+    for (int i = 1; i <= half; i++) {
+      result[idx++] = i;
     }
-    return arr;
+    return result;
   }
 }

From 1e8651b810299592d9fc5ea033227a822173edc3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Jun 2022 09:49:08 -0700
Subject: [PATCH 1043/2175] Update Reverse Words in a String.java

---
 Medium/Reverse Words in a String.java | 61 ++++++++++++++++++---------
 1 file changed, 41 insertions(+), 20 deletions(-)

diff --git a/Medium/Reverse Words in a String.java b/Medium/Reverse Words in a String.java
index 491b3d51..4d70c9e9 100644
--- a/Medium/Reverse Words in a String.java	
+++ b/Medium/Reverse Words in a String.java	
@@ -1,28 +1,49 @@
 class Solution {
   public String reverseWords(String s) {
-    Stack<String> stack = new Stack<>();
-    StringBuilder sb = new StringBuilder();
-    int idx = 0;
-    int n = s.length();
-    while (idx < n) {
-      if (s.charAt(idx) != ' ') {
-        sb.append(s.charAt(idx));
-      }
-      if (s.charAt(idx) == ' ' || idx == n - 1) {
-        if (sb.length() > 0) {
-          stack.push(sb.toString());
-          sb.setLength(0);
-        }
+    StringBuilder sb = trimSpace(s);
+    reverse(sb, 0, sb.length() - 1);
+    int start = 0;
+    int end = 0;
+    int n = sb.length();
+    while (start < n) {
+      while (end < n && sb.charAt(end) != ' ') {
+        end++;
       }
-      idx++;
+      reverse(sb, start, end - 1);
+      start = end + 1;
+      end++;
+    }
+    return sb.toString();
+  }
+  
+  private void reverse(StringBuilder sb, int start, int end) {
+    while (start <= end) {
+      char temp = sb.charAt(start);
+      sb.setCharAt(start++, sb.charAt(end));
+      sb.setCharAt(end--, temp);
     }
-    sb.setLength(0);
-    while (!stack.isEmpty()) {
-      sb.append(stack.pop());
-      if (!stack.isEmpty()) {
-        sb.append(" ");
+  }
+  
+  private StringBuilder trimSpace(String s) {
+    StringBuilder sb = new StringBuilder();
+    int start = 0;
+    int end = s.length() - 1;
+    while (start <= end && s.charAt(start) == ' ') {
+      start++;
+    }
+    while (end >= start && s.charAt(end) == ' ') {
+      end--;
+    }
+    while (start <= end) {
+      if (s.charAt(start) != ' ') {
+        sb.append(s.charAt(start++));
+      } else {
+        if (sb.charAt(sb.length() - 1) != ' ') {
+          sb.append(s.charAt(start));
+        }
+        start++;
       }
     }
-    return sb.toString();
+    return sb;
   }
 }

From 8bfb9b0fd0c62012b518b22b165f21434392a5aa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Jun 2022 14:24:49 -0700
Subject: [PATCH 1044/2175] Update Add Two Numbers II.java

---
 Medium/Add Two Numbers II.java | 93 ++++++++++++++--------------------
 1 file changed, 37 insertions(+), 56 deletions(-)

diff --git a/Medium/Add Two Numbers II.java b/Medium/Add Two Numbers II.java
index ae9591cd..fe08935f 100644
--- a/Medium/Add Two Numbers II.java	
+++ b/Medium/Add Two Numbers II.java	
@@ -3,65 +3,46 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-        ListNode l1Rev = reverse(l1);
-        ListNode l2Rev = reverse(l2);
-        
-        ListNode ans = new ListNode(-1);
-        ListNode curr = ans;
-        int carry = 0;
-        
-        while (l1Rev != null || l2Rev != null) {
-            int temp = 0;
-            if (l1Rev != null && l2Rev != null) {
-                temp = l1Rev.val + l2Rev.val + carry;
-                l1Rev = l1Rev.next;
-                l2Rev = l2Rev.next;
-            }
-            else if(l1Rev != null) {
-                temp = l1Rev.val + carry;
-                l1Rev = l1Rev.next;
-            }
-            else {
-                temp = l2Rev.val + carry;
-                l2Rev = l2Rev.next;
-            }
-            
-            if (temp > 9) {
-                carry = temp/10;
-                temp = temp%10;
-            }
-            else {
-                carry = 0;
-            }
-            curr.next = new ListNode(temp);
-            curr = curr.next;
-        }
-        
-        if (carry != 0) {
-            curr.next = new ListNode(carry);
-            curr = curr.next;
-        }
-        
-        return reverse(ans.next);
+  public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+    ListNode revL1 = reverse(l1);
+    ListNode revL2 = reverse(l2);
+    ListNode dummy = new ListNode(0);
+    ListNode curr = dummy;
+    int carry = 0;
+    while (revL1 != null || revL2 != null || carry != 0) {
+      if (revL1 != null && revL2 != null) {
+        carry += revL1.val + revL2.val;
+        revL1 = revL1.next;
+        revL2 = revL2.next;
+      } else if (revL1 != null && revL2 == null) {
+        carry += revL1.val;
+        revL1 = revL1.next;
+      } else if (revL1 == null && revL2 != null) {
+        carry += revL2.val;
+        revL2 = revL2.next;
+      }
+      curr.next = new ListNode(carry % 10);
+      carry /= 10;
+      curr = curr.next;
     }
-    
-    private ListNode reverse(ListNode head) {
-        ListNode curr = head;
-        ListNode prev = null;
-        ListNode next = null;
-        
-        while (curr != null) {
-            next = curr.next;
-            curr.next = prev;
-            prev = curr;
-            curr = next;
-        }
-        
-        return prev;
+    return reverse(dummy.next);
+  }
+  
+  private ListNode reverse(ListNode root) {
+    ListNode curr = root;
+    ListNode prev = null;
+    while (curr != null) {
+      ListNode next = curr.next;
+      curr.next = prev;
+      prev = curr;
+      curr = next;
     }
+    return prev;
+  }
 }

From 772e260fdd31f2f88fd6477643e708b2dcb97d60 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Jun 2022 17:02:36 -0700
Subject: [PATCH 1045/2175] Update Find Words That Can Be Formed by
 Characters.java

---
 ...ords That Can Be Formed by Characters.java | 36 +++++++++----------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/Easy/Find Words That Can Be Formed by Characters.java b/Easy/Find Words That Can Be Formed by Characters.java
index 46d11d0f..1dce1552 100644
--- a/Easy/Find Words That Can Be Formed by Characters.java	
+++ b/Easy/Find Words That Can Be Formed by Characters.java	
@@ -1,29 +1,27 @@
 class Solution {
   public int countCharacters(String[] words, String chars) {
-    Map<Character, Integer> charFreq = getMap(chars);
-    int length = 0;
-    for (String word : words) {
-      if (canBeFormed(charFreq, getMap(word))) {
-        length += word.length();
-      }
-    }
-    return length;
-  }
-  
-  private Map<Character, Integer> getMap(String s) {
-    Map<Character, Integer> map = new HashMap<>();
-    for (char c : s.toCharArray()) {
-      map.put(c, map.getOrDefault(c, 0) + 1);
-    }
-    return map;
+    Map<Character, Integer> frequency = getFrequencyMap(chars);
+    return Arrays.stream(words)
+      .filter(word -> canBeFormed(word, frequency))
+      .map(word -> word.length())
+      .reduce(0, Integer::sum);
   }
   
-  private boolean canBeFormed(Map<Character, Integer> main, Map<Character, Integer> toBeChecked) {
-    for (Character key : toBeChecked.keySet()) {
-      if (main.getOrDefault(key, 0) < toBeChecked.get(key)) {
+  private boolean canBeFormed(String word, Map<Character, Integer> frequency) {
+    Map<Character, Integer> wordFrequency = getFrequencyMap(word);
+    for (Character key : wordFrequency.keySet()) {
+      if (frequency.getOrDefault(key, 0) < wordFrequency.get(key)) {
         return false;
       }
     }
     return true;
   }
+  
+  private Map<Character, Integer> getFrequencyMap(String s) {
+    Map<Character, Integer> frequency = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      frequency.put(c, frequency.getOrDefault(c, 0) + 1);
+    }
+    return frequency;
+  }
 }

From 5ae4cf113002be4d20623d25bb2c316287255da3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Jun 2022 17:37:37 -0700
Subject: [PATCH 1046/2175] Create Remove Palindromic Subsequences.java

---
 Easy/Remove Palindromic Subsequences.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Remove Palindromic Subsequences.java

diff --git a/Easy/Remove Palindromic Subsequences.java b/Easy/Remove Palindromic Subsequences.java
new file mode 100644
index 00000000..e4e10845
--- /dev/null
+++ b/Easy/Remove Palindromic Subsequences.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int removePalindromeSub(String s) {
+    if (s.length() == 0) {
+      return 0;
+    }
+    int start = 0;
+    int end = s.length() - 1;
+    while (start <= end) {
+      if (s.charAt(start) != s.charAt(end)) {
+        return 2;
+      }
+      start++;
+      end--;
+    }
+    return 1;
+  }
+}

From 8d984d35b2fca88d7536369055ee20a512e5f7cb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Jun 2022 08:17:56 -0700
Subject: [PATCH 1047/2175] Create Minimum Swaps to Group All 1's Together.java

---
 ...nimum Swaps to Group All 1's Together.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Minimum Swaps to Group All 1's Together.java

diff --git a/Medium/Minimum Swaps to Group All 1's Together.java b/Medium/Minimum Swaps to Group All 1's Together.java
new file mode 100644
index 00000000..ea3d82c8
--- /dev/null
+++ b/Medium/Minimum Swaps to Group All 1's Together.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int minSwaps(int[] data) {
+    int totalOnes = 0;
+    for (int num : data) {
+      totalOnes += num;
+    }
+    int leftIdx = 0;
+    int rightIdx = 0;
+    int currOnes = 0;
+    int maxOnes = 0;
+    while (rightIdx < data.length) {
+      currOnes += data[rightIdx++];
+      if (rightIdx - leftIdx > totalOnes) {
+        currOnes -= data[leftIdx++];
+      }
+      maxOnes = Math.max(maxOnes, currOnes);
+    }
+    return totalOnes - maxOnes;
+  }
+}

From 813273dd3c081936d140a5daa2d21308ff61d702 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Jun 2022 11:33:33 -0700
Subject: [PATCH 1048/2175] Update Longest Palindrome.java

---
 Easy/Longest Palindrome.java | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/Easy/Longest Palindrome.java b/Easy/Longest Palindrome.java
index 59688ba8..aa91e564 100644
--- a/Easy/Longest Palindrome.java	
+++ b/Easy/Longest Palindrome.java	
@@ -4,16 +4,15 @@ public int longestPalindrome(String s) {
     for (char c : s.toCharArray()) {
       map.put(c, map.getOrDefault(c, 0) + 1);
     }
-    int count = 0;
+    int totalLength = 0;
     boolean oddTaken = false;
     for (Character key : map.keySet()) {
-      int val = map.get(key);
-      count += (val / 2) * 2;
-      if ((val == 1 || val % 2 != 0) && !oddTaken) {
-        oddTaken = true;
-        count++;
+      totalLength += (map.get(key) / 2) * 2;
+      if (!oddTaken && map.get(key) % 2 != 0) {
+        totalLength++;
+        oddTaken = !oddTaken;
       }
     }
-    return count;
+    return totalLength;
   }
 }

From 927d5a48cf82a965ef9b0cac6616556c08896cec Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Jun 2022 11:34:18 -0700
Subject: [PATCH 1049/2175] Update K Closest Points to Origin.java

---
 Medium/K Closest Points to Origin.java | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/Medium/K Closest Points to Origin.java b/Medium/K Closest Points to Origin.java
index 20275fe3..4f92b4a6 100644
--- a/Medium/K Closest Points to Origin.java	
+++ b/Medium/K Closest Points to Origin.java	
@@ -1,15 +1,20 @@
 class Solution {
   public int[][] kClosest(int[][] points, int k) {
-    PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> {
-      double diff =  Math.sqrt(o1[0] * o1[0] + o1[1] * o1[1]) - Math.sqrt(
-          o2[0] * o2[0] + o2[1] * o2[1]);
-      return diff < 0 ? -1 : (diff > 0 ? 1 : 0);
-    });
-    Collections.addAll(pq, points);
-    int[][] result = new int[k][2];
-    for (int i = 0; i < k; i++) {
+    PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> getDistance(o2) - getDistance(o1));
+    for (int[] point : points) {
+      pq.add(point);
+      if (pq.size() > k) {
+        pq.poll();
+      }
+    }
+    int[][] result = new int[pq.size()][2];
+    for (int i = 0; i < result.length; i++) {
       result[i] = pq.poll();
     }
     return result;
   }
+
+  private int getDistance(int[] point) {
+    return (point[0] * point[0]) + (point[1] * point[1]);
+  }
 }

From 404be1017861fad7c7e4e6f8dd0af52a8e95523b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Jun 2022 11:35:32 -0700
Subject: [PATCH 1050/2175] Update Longest Palindromic Substring.java

---
 Medium/Longest Palindromic Substring.java | 42 +++++++++++------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/Medium/Longest Palindromic Substring.java b/Medium/Longest Palindromic Substring.java
index aee6dd60..c22fec2d 100644
--- a/Medium/Longest Palindromic Substring.java	
+++ b/Medium/Longest Palindromic Substring.java	
@@ -1,26 +1,24 @@
 class Solution {
-    
-    public boolean isPalindrome(String s,int begin, int end) {
-        if (begin < 0) return false;
-        while(begin < end) {
-            if (s.charAt(begin++) != s.charAt(end--)) return false; 
-        }
-        return true;
+  public String longestPalindrome(String s) {
+    int start = 0;
+    int end = 0;
+    for (int i = 0; i < s.length(); i++) {
+      int lenOne = helper(s, i, i);
+      int lenTwo = helper(s, i, i + 1);
+      int maxLength = Math.max(lenOne, lenTwo);
+      if (maxLength > end - start) {
+        start = i - (maxLength - 1) / 2;
+        end = i + maxLength / 2;
+      }
     }
-    
-    public String longestPalindrome(String s) {
-        String res = "";
-        int currLength = 0;
-        for (int i=0;i<s.length();i++) {
-            if (isPalindrome(s,i-currLength-1,i)) {
-                res = s.substring(i-currLength-1,i+1);
-                currLength += 2;
-            } 
-            else if (isPalindrome(s,i-currLength,i)) {
-                res = s.substring(i-currLength,i+1);
-                currLength += 1;
-            }
-        }
-        return res;
+    return s.substring(start, end + 1);
+  }
+  
+  private int helper(String s, int left, int right) {
+    while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
+      left--;
+      right++;
     }
+    return right - left - 1;
+  }
 }

From 525d1fd7f403bb6affa319fadce3aabeaa4d3428 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Jun 2022 16:04:02 -0700
Subject: [PATCH 1051/2175] Update and rename Fibonacci Numbers.java to
 Fibonacci Number.java

---
 Easy/Fibonacci Number.java  | 14 ++++++++++++++
 Easy/Fibonacci Numbers.java | 20 --------------------
 2 files changed, 14 insertions(+), 20 deletions(-)
 create mode 100644 Easy/Fibonacci Number.java
 delete mode 100644 Easy/Fibonacci Numbers.java

diff --git a/Easy/Fibonacci Number.java b/Easy/Fibonacci Number.java
new file mode 100644
index 00000000..dfd1ea21
--- /dev/null
+++ b/Easy/Fibonacci Number.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int fib(int n) {
+    if (n == 0) {
+      return 0;
+    }
+    int[] result = new int[n + 1];
+    result[0] = 0;
+    result[1] = 1;
+    for (int i = 2; i <= n; i++) {
+      result[i] = result[i - 1] + result[i - 2];
+    }
+    return result[n];
+  }
+}
diff --git a/Easy/Fibonacci Numbers.java b/Easy/Fibonacci Numbers.java
deleted file mode 100644
index f5e33e3b..00000000
--- a/Easy/Fibonacci Numbers.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-  public int fib(int N) {
-    Integer[] memo = new Integer[N + 1];
-    return getFib(memo, N);
-  }
-  
-  private int getFib(Integer[] memo, int N) {
-    if (memo[N] != null) {
-      return memo[N];
-    }
-    else if (N == 0) {
-      return 0;
-    }
-    else if (N == 1) {
-      return 1;
-    }
-    memo[N] = getFib(memo, N - 1) + getFib(memo, N - 2);
-    return memo[N];
-  }
-}

From e4d27f97ce65aaebcd069c1e27e5ab97112ac70f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Jun 2022 07:56:26 -0700
Subject: [PATCH 1052/2175] Update and rename Two Sum II.java to Two Sum II -
 Input Array Is Sorted.java

---
 Easy/Two Sum II - Input Array Is Sorted.java | 17 +++++++++++++++++
 Easy/Two Sum II.java                         | 19 -------------------
 2 files changed, 17 insertions(+), 19 deletions(-)
 create mode 100644 Easy/Two Sum II - Input Array Is Sorted.java
 delete mode 100644 Easy/Two Sum II.java

diff --git a/Easy/Two Sum II - Input Array Is Sorted.java b/Easy/Two Sum II - Input Array Is Sorted.java
new file mode 100644
index 00000000..f896157c
--- /dev/null
+++ b/Easy/Two Sum II - Input Array Is Sorted.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int[] twoSum(int[] numbers, int target) {
+    int leftIdx = 0;
+    int rightIdx = numbers.length - 1;
+    while (leftIdx < rightIdx) {
+      int currSum = numbers[leftIdx] + numbers[rightIdx];
+      if (currSum == target) {
+        return new int[]{leftIdx + 1, rightIdx + 1};
+      } else if (currSum > target) {
+        rightIdx--;
+      } else {
+        leftIdx++;
+      }
+    }
+    return new int[]{0};
+  }
+}
diff --git a/Easy/Two Sum II.java b/Easy/Two Sum II.java
deleted file mode 100644
index 6d313038..00000000
--- a/Easy/Two Sum II.java	
+++ /dev/null
@@ -1,19 +0,0 @@
-class Solution {
-    public int[] twoSum(int[] numbers, int target) {
-        int[] ans = new int[2];
-        int i = 0; 
-        int j = numbers.length-1;
-        while (numbers[i] + numbers[j] != target) {
-            if (numbers[i] + numbers[j] > target) {
-                j--;
-            }
-            else {
-                i++;
-            }
-        }
-        ans[0] = i+1;
-        ans[1] = j+1;
-        
-        return ans;
-    }
-}

From 65fcb29fa250898b419017ed1352e3fcac6c5703 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Jun 2022 07:56:45 -0700
Subject: [PATCH 1053/2175] Rename Easy/Two Sum II - Input Array Is Sorted.java
 to Medium/Two Sum II - Input Array Is Sorted.java

---
 {Easy => Medium}/Two Sum II - Input Array Is Sorted.java | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {Easy => Medium}/Two Sum II - Input Array Is Sorted.java (100%)

diff --git a/Easy/Two Sum II - Input Array Is Sorted.java b/Medium/Two Sum II - Input Array Is Sorted.java
similarity index 100%
rename from Easy/Two Sum II - Input Array Is Sorted.java
rename to Medium/Two Sum II - Input Array Is Sorted.java

From aa80afc99264da8c29385086511b948e6f73aa44 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Jun 2022 16:32:00 -0700
Subject: [PATCH 1054/2175] Update Rotting Oranges.java

---
 Medium/Rotting Oranges.java | 52 +++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 28 deletions(-)

diff --git a/Medium/Rotting Oranges.java b/Medium/Rotting Oranges.java
index 39ea7886..dd9a1be5 100644
--- a/Medium/Rotting Oranges.java	
+++ b/Medium/Rotting Oranges.java	
@@ -1,41 +1,37 @@
 class Solution {
-  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
   public int orangesRotting(int[][] grid) {
-    Queue<int[]> infectedOranges = new LinkedList<>();
-    int numOfFreshOranges = 0;
-    for (int i = 0; i < grid.length; i++) {
-      for (int j = 0; j < grid[i].length; j++) {
+    Queue<int[]> queue = new LinkedList<>();
+    int nonRottenCount = 0;
+    int numRows = grid.length;
+    int numCols = grid[0].length;
+    for (int i = 0; i < numRows; i++) {
+      for (int j = 0; j < numCols; j++) {
         if (grid[i][j] == 2) {
-          infectedOranges.add(new int[]{i, j});
+          queue.add(new int[]{i, j});
+        } else if (grid[i][j] == 1) {
+          nonRottenCount++;
         }
-        numOfFreshOranges += grid[i][j] == 1 ? 1 : 0;
       }
     }
-    int numOfMinutes = 0;
-    while (!infectedOranges.isEmpty()) {
-      int infectedOrangeSize = infectedOranges.size();
-      boolean newInfected = false;
-      while (infectedOrangeSize-- > 0) {
-        int[] infectedOrangeCoordinate = infectedOranges.poll();
+    int totalTime = 0;
+    while (!queue.isEmpty() && nonRottenCount > 0) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int[] removed = queue.remove();
         for (int[] dir : DIRS) {
-          int newRowCoordinate = infectedOrangeCoordinate[0] + dir[0];
-          int newColCoordinate = infectedOrangeCoordinate[1] + dir[1];
-          if (isValidInfection(grid, newRowCoordinate, newColCoordinate)) {
-            infectedOranges.add(new int[]{newRowCoordinate, newColCoordinate});
-            grid[newRowCoordinate][newColCoordinate] = 2;
-            newInfected = true;
-            numOfFreshOranges--;
+          int newX = removed[0] + dir[0];
+          int newY = removed[1] + dir[1];
+          if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && grid[newX][newY] == 1) {
+            grid[newX][newY] = 2;
+            nonRottenCount--;
+            queue.add(new int[]{newX, newY});
           }
         }
       }
-      numOfMinutes += newInfected ? 1 : 0;
+      totalTime++;
     }
-    return numOfFreshOranges > 0 ? -1 : numOfMinutes;
-  }
-
-  private boolean isValidInfection(int[][] grid, int rowCoordinate, int colCoordinate) {
-    return rowCoordinate >= 0 && colCoordinate >= 0 && rowCoordinate < grid.length
-        && colCoordinate < grid[0].length && grid[rowCoordinate][colCoordinate] == 1;
+    return nonRottenCount == 0 ? totalTime : -1;
   }
 }

From f34aa47d225ef745f5203fc14144a5bcbc7b2212 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 10 Jun 2022 11:28:41 -0700
Subject: [PATCH 1055/2175] Update and rename Easy/Two City Scheduling.java to
 Medium/Two City Scheduling.java

---
 Easy/Two City Scheduling.java   | 15 ---------------
 Medium/Two City Scheduling.java | 11 +++++++++++
 2 files changed, 11 insertions(+), 15 deletions(-)
 delete mode 100644 Easy/Two City Scheduling.java
 create mode 100644 Medium/Two City Scheduling.java

diff --git a/Easy/Two City Scheduling.java b/Easy/Two City Scheduling.java
deleted file mode 100644
index 6bcb5602..00000000
--- a/Easy/Two City Scheduling.java	
+++ /dev/null
@@ -1,15 +0,0 @@
-class Solution {
-  public int twoCitySchedCost(int[][] costs) {
-    Arrays.sort(costs, new Comparator<int[]>(){
-      public int compare(int[] o1, int[] o2) {
-       return o1[0] - o1[1] - (o2[0] - o2[1]); 
-      }
-    });
-    int total = 0;
-    int n = costs.length / 2;
-    for (int i = 0; i < n; i++) {
-      total += costs[i][0] + costs[i + n][1];
-    }
-    return total;
-  }
-}
diff --git a/Medium/Two City Scheduling.java b/Medium/Two City Scheduling.java
new file mode 100644
index 00000000..6f75aeda
--- /dev/null
+++ b/Medium/Two City Scheduling.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int twoCitySchedCost(int[][] costs) {
+    Arrays.sort(costs, (o1, o2) -> o1[0] - o1[1] - (o2[0] - o2[1]));
+    int total = 0;
+    int n = costs.length / 2;
+    for (int i = 0; i < n; ++i) {
+      total += costs[i][0] + costs[i + n][1];
+    }
+    return total;
+  }
+}

From 4efda243330a57edeb80397dd735a1735564c181 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 10 Jun 2022 11:35:02 -0700
Subject: [PATCH 1056/2175] Update Invalid Transactions.java

---
 Medium/Invalid Transactions.java | 68 ++++++++++++++------------------
 1 file changed, 30 insertions(+), 38 deletions(-)

diff --git a/Medium/Invalid Transactions.java b/Medium/Invalid Transactions.java
index 1d0d9b6d..aa48c7db 100644
--- a/Medium/Invalid Transactions.java	
+++ b/Medium/Invalid Transactions.java	
@@ -1,46 +1,38 @@
 class Solution {
   public List<String> invalidTransactions(String[] transactions) {
-    Map<String, List<Transaction>> map = new HashMap<>();
-    Set<String> invalidTransactions = new HashSet<>();
-    for (int i = 0; i < transactions.length; i++) {
-      String[] details = transactions[i].split(",");
-      String name = details[0];
-      int time = Integer.parseInt(details[1]);
-      int amount = Integer.parseInt(details[2]);
-      String city = details[3];
+    Set<String> invalidTransactionSet = new HashSet<>();
+    Map<String, List<String>> map = new HashMap<>();
+    Map<String, Integer> transactionOccurenceCount = new HashMap<>();
+    for (String transactionString : transactions) {
+      transactionOccurenceCount.put(transactionString, transactionOccurenceCount.getOrDefault(transactionString, 0) + 1);
+      String[] transaction = transactionString.split(",");
+      String name = transaction[0];
+      int amount = Integer.parseInt(transaction[2]);
+      String city = transaction[3];
+      int time = Integer.parseInt(transaction[1]);
       if (amount > 1000) {
-        invalidTransactions.add(transactions[i]);
-      }
-      if (map.containsKey(name)) {
-        List<Transaction> otherTransactions = map.get(name);
-        for (Transaction transaction : otherTransactions) {
-          if (!transaction.city.equals(city) && Math.abs(transaction.time - time) <= 60) {
-            invalidTransactions.add(transactions[transaction.idx]);
-            invalidTransactions.add(transactions[i]);
-          }
+        invalidTransactionSet.add(transactionString);
+      } 
+      map.computeIfAbsent(name, k -> new ArrayList<>());
+      List<String> currentTransactions = map.get(name);
+      for (String currentTransaction : currentTransactions) {
+        String currentCity = currentTransaction.split(",")[3];
+        int currentTime = Integer.parseInt(currentTransaction.split(",")[1]);
+        if (!currentCity.equals(city) && Math.abs(time - currentTime) <= 60) {
+          invalidTransactionSet.add(currentTransaction);
+          invalidTransactionSet.add(transactionString);
         }
       }
-      map.computeIfAbsent(name, k -> new ArrayList<>()).add(
-        new Transaction(name, time, amount, city, i)
-      );
+      currentTransactions.add(transactionString);
+      map.put(name, currentTransactions);
     }
-    return new ArrayList<>(invalidTransactions);
-  }
-}
-
-
-class Transaction {
-  String name;
-  int time;
-  int amount;
-  String city;
-  int idx;
-  
-  public Transaction(String name, int time, int amount, String city, int idx) {
-    this.name = name;
-    this.time = time;
-    this.amount = amount;
-    this.city = city;
-    this.idx = idx;
+    List<String> result = new ArrayList<>();
+    for (String trs : invalidTransactionSet) {
+      int count = transactionOccurenceCount.get(trs);
+      while (count-- > 0) {
+        result.add(trs);
+      }
+    }
+    return result;
   }
 }

From 4b9b2546cb8cabba13e40d01742b51118ee84f79 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 10 Jun 2022 14:00:18 -0700
Subject: [PATCH 1057/2175] Update Number of Provinces.java

---
 Medium/Number of Provinces.java | 66 ++++++++++-----------------------
 1 file changed, 20 insertions(+), 46 deletions(-)

diff --git a/Medium/Number of Provinces.java b/Medium/Number of Provinces.java
index 436059e3..4f485f0d 100644
--- a/Medium/Number of Provinces.java	
+++ b/Medium/Number of Provinces.java	
@@ -1,60 +1,34 @@
 class Solution {
   public int findCircleNum(int[][] isConnected) {
     int n = isConnected.length;
-    DisjointSet disjointSet = new DisjointSet(n);
+    Map<Integer, Set<Integer>> map = new HashMap<>();
     for (int i = 0; i < n; i++) {
       for (int j = 0; j < n; j++) {
-        if (isConnected[i][j] == 1) {
-          disjointSet.union(i, j);
+        if (i != j && isConnected[i][j] == 1) {
+          map.computeIfAbsent(i, k -> new HashSet<>()).add(j);
+          map.computeIfAbsent(j, k -> new HashSet<>()).add(i);
         }
       }
     }
-    Set<Integer> set = new HashSet<>();
+    Set<Integer> visited = new HashSet<>();
+    int provinceCount = 0;
     for (int i = 0; i < n; i++) {
-      set.add(disjointSet.find(i));
-    }
-    return set.size();
-  }
-
-  private static class DisjointSet {
-
-    private final int[] root;
-    private final int[] rank;
-
-    public DisjointSet(int size) {
-      this.root = new int[size];
-      this.rank = new int[size];
-      for (int i = 0; i < size; i++) {
-        this.root[i] = i;
-        this.rank[i] = 1;
-      }
-    }
-
-    public void union(int nodeOne, int nodeTwo) {
-      int rootOne = find(nodeOne);
-      int rootTwo = find(nodeTwo);
-      if (rootOne != rootTwo) {
-        if (this.rank[rootOne] > this.rank[rootTwo]) {
-          this.root[rootTwo] = rootOne;
-        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
-          this.root[rootOne] = rootTwo;
-        } else {
-          this.root[rootTwo] = rootOne;
-          this.rank[rootOne]++;
+      if (!visited.contains(i)) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(i);
+        visited.add(i);
+        while (!queue.isEmpty()) {
+          int removed = queue.remove();
+          for (Integer connection : map.getOrDefault(removed, new HashSet<>())) {
+            if (!visited.contains(connection)) {
+              queue.add(connection);
+              visited.add(connection);
+            }
+          }
         }
+        provinceCount++;
       }
     }
-
-
-    public int find(int node) {
-      if (node == root[node]) {
-        return node;
-      }
-      return root[node] = find(root[node]);
-    }
-
-    public boolean connected(int nodeOne, int nodeTwo) {
-      return find(nodeOne) == find(nodeTwo);
-    }
+    return provinceCount;
   }
 }

From ead55b4b53b49331b586c3b4611f12e51189a7c2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 10 Jun 2022 16:34:04 -0700
Subject: [PATCH 1058/2175] Update Count Servers That Communicate.java

---
 Medium/Count Servers That Communicate.java | 46 ++++++++++------------
 1 file changed, 20 insertions(+), 26 deletions(-)

diff --git a/Medium/Count Servers That Communicate.java b/Medium/Count Servers That Communicate.java
index 81a2c8ff..34de8d30 100644
--- a/Medium/Count Servers That Communicate.java	
+++ b/Medium/Count Servers That Communicate.java	
@@ -1,31 +1,25 @@
 class Solution {
-    public int countServers(int[][] grid) {
-        if (grid.length == 0 || grid[0].length == 0) {
-            return 0;
+  public int countServers(int[][] grid) {
+    int m = grid.length;
+    int n = grid[0].length;
+    int[] rowCount = new int[m];
+    int[] colCount = new int[n];
+    for (int i = 0; i < m; i++) {
+      for (int j = 0; j < n; j++) {
+        if (grid[i][j] == 1) {
+          rowCount[i]++;
+          colCount[j]++;
         }
-        int numRows = grid.length;
-        int numCols = grid[0].length;
-        int[] rowCount = new int[numRows];
-        int[] colCount = new int[numCols];
-        int numOfServers = 0;
-        for (int i = 0; i < numRows; i++) {
-            for (int j = 0; j < numCols; j++) {
-                if (grid[i][j] == 1) {
-                    numOfServers++;
-                    rowCount[i]++;
-                    colCount[j]++;
-                }
-            }
-        }
-        for (int i = 0; i < numRows; i++) {
-            for (int j = 0; j < numCols; j++) {
-                if (grid[i][j] == 1) {
-                    if (rowCount[i] == 1 && colCount[j] == 1) {
-                        numOfServers--;
-                    }
-                }
-            }
+      }
+    }
+    int connectedServerCount = 0;
+    for (int i = 0; i < m; i++) {
+      for (int j = 0; j < n; j++) {
+        if (grid[i][j] == 1 && (rowCount[i] > 1 || colCount[j] > 1)) {
+          connectedServerCount++;
         }
-        return numOfServers;
+      }
     }
+    return connectedServerCount;
+  }
 }

From ca359c3435bfefb3f4e8fc50594a708e18fca15e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 11 Jun 2022 07:02:33 -0700
Subject: [PATCH 1059/2175] Update Minimum Operations to Reduce X to Zero.java

---
 ...inimum Operations to Reduce X to Zero.java | 31 ++++++++-----------
 1 file changed, 13 insertions(+), 18 deletions(-)

diff --git a/Medium/Minimum Operations to Reduce X to Zero.java b/Medium/Minimum Operations to Reduce X to Zero.java
index ebd3de44..3e202cb6 100644
--- a/Medium/Minimum Operations to Reduce X to Zero.java	
+++ b/Medium/Minimum Operations to Reduce X to Zero.java	
@@ -1,26 +1,21 @@
 class Solution {
   public int minOperations(int[] nums, int x) {
-    int n = nums.length;
-    int leftIdx = 0;
-    int sum = 0;
-    int ans = -1;
-    for (; leftIdx < n && sum < x; leftIdx++) {
-      sum += nums[leftIdx];
+    int totalSum = 0;
+    for (int num : nums) {
+      totalSum += num;
     }
-    if (sum == x) {
-      ans = leftIdx;
-    }
-    leftIdx--;
-    int rightIdx = n - 1;
-    for (; leftIdx >= 0; leftIdx--) {
-      sum -= nums[leftIdx];
-      while (rightIdx > leftIdx && sum < x) {
-        sum += nums[rightIdx--];
+    int max = -1;
+    int left = 0;
+    int current = 0;
+    for (int right = 0; right < nums.length; right++) {
+      current += nums[right];
+      while (current > totalSum - x && left <= right) {
+        current -= nums[left++];
       }
-      if (sum == x) {
-        ans = ans == -1 ? (leftIdx + n - rightIdx - 1) : Math.min(ans, (leftIdx + n - rightIdx - 1));
+      if (current == totalSum - x) {
+        max = Math.max(max, right - left + 1);
       }
     }
-    return ans;
+    return max != -1 ? nums.length - max : -1;
   }
 }

From f2a4599df09673a9aa3d152c2cc7f53693dd5cd9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 11 Jun 2022 07:23:49 -0700
Subject: [PATCH 1060/2175] Update Convert Sorted Array To Binary Search
 Tree.java

---
 ...rt Sorted Array To Binary Search Tree.java | 22 +++++++++++--------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/Easy/Convert Sorted Array To Binary Search Tree.java b/Easy/Convert Sorted Array To Binary Search Tree.java
index 55cbd37e..19d14059 100644
--- a/Easy/Convert Sorted Array To Binary Search Tree.java	
+++ b/Easy/Convert Sorted Array To Binary Search Tree.java	
@@ -4,24 +4,28 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public TreeNode sortedArrayToBST(int[] nums) {
-    int left = 0;
-    int right = nums.length - 1;
-    return helper(nums, left, right);
+    return helper(nums, 0, nums.length - 1);
   }
   
-  private TreeNode helper(int[] nums, int left, int right) {
-    if (left > right) {
+  private TreeNode helper(int[] nums, int start, int end) {
+    if (start > end) {
       return null;
     }
-    int mid = (left + right) / 2;
+    int mid = (start + end) / 2;
     TreeNode root = new TreeNode(nums[mid]);
-    root.left = helper(nums, left, mid - 1);
-    root.right = helper(nums, mid + 1, right);
+    root.left = helper(nums, start, mid - 1);
+    root.right = helper(nums, mid + 1, end);
     return root;
   }
 }

From d1992181dfde6fb3c5fa251326260a9da20e7f4e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 11 Jun 2022 08:04:11 -0700
Subject: [PATCH 1061/2175] Update and rename Leaf Similar Tree.java to
 Leaf-Similar Trees.java

---
 Easy/Leaf Similar Tree.java  | 39 ---------------------------------
 Easy/Leaf-Similar Trees.java | 42 ++++++++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 39 deletions(-)
 delete mode 100644 Easy/Leaf Similar Tree.java
 create mode 100644 Easy/Leaf-Similar Trees.java

diff --git a/Easy/Leaf Similar Tree.java b/Easy/Leaf Similar Tree.java
deleted file mode 100644
index 5b79aa91..00000000
--- a/Easy/Leaf Similar Tree.java	
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode() {}
- *     TreeNode(int val) { this.val = val; }
- *     TreeNode(int val, TreeNode left, TreeNode right) {
- *         this.val = val;
- *         this.left = left;
- *         this.right = right;
- *     }
- * }
- */
-class Solution {
-  public boolean leafSimilar(TreeNode root1, TreeNode root2) {
-    return getLeafSequence(root1).equals(getLeafSequence(root2));
-  }
-  
-  private String getLeafSequence(TreeNode root) {
-    List<Integer> list = new ArrayList<>();
-    helper(root, list);
-    return list.toString();
-  }
-  
-  private void helper(TreeNode root, List<Integer> list) {
-    if (root == null) {
-      return;
-    }
-    if (root.left == null && root.right == null) {
-      list.add(root.val);
-    }
-    else {
-      helper(root.left, list);
-      helper(root.right, list);
-    }
-  }
-}
diff --git a/Easy/Leaf-Similar Trees.java b/Easy/Leaf-Similar Trees.java
new file mode 100644
index 00000000..38bb0ab9
--- /dev/null
+++ b/Easy/Leaf-Similar Trees.java	
@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+    return getLeaves(root1).equals(getLeaves(root2));
+  }   
+  
+  private List<Integer> getLeaves(TreeNode root) {
+    Stack<TreeNode> stack = new Stack<>();
+    List<Integer> leaves = new ArrayList<>();
+    while (root != null) {
+      stack.push(root);
+      root = root.left;
+    }
+    while (!stack.isEmpty()) {
+      TreeNode removed = stack.pop();
+      if (removed.left == null && removed.right == null) {
+        leaves.add(removed.val);
+      } else {
+        TreeNode rightNode = removed.right;
+        while (rightNode != null) {
+          stack.push(rightNode);
+          rightNode = rightNode.left;
+        }
+      }
+    }
+    return leaves;
+  }
+}

From a4c165e4b45abba700fc11ed2821249c3f4719d7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 11 Jun 2022 09:26:37 -0700
Subject: [PATCH 1062/2175] Create Strong Password Checker II.java

---
 Easy/Strong Password Checker II.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Strong Password Checker II.java

diff --git a/Easy/Strong Password Checker II.java b/Easy/Strong Password Checker II.java
new file mode 100644
index 00000000..56e82a98
--- /dev/null
+++ b/Easy/Strong Password Checker II.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public boolean strongPasswordCheckerII(String password) {
+    boolean lowerCaseFound = false;
+    boolean upperCaseFound = false;
+    boolean digitFound = false;
+    boolean specialCharFound = false;
+    String specialChars = "!@#$%^&*()-+";
+    for (int i = 0; i < password.length(); i++) {
+      char c = password.charAt(i);
+      if (specialChars.indexOf(c) != -1) {
+        specialCharFound = true;
+      } else if (Character.isDigit(c)) {
+        digitFound = true;
+      } else if (Character.isUpperCase(c)) {
+        upperCaseFound = true;
+      } else if (Character.isLowerCase(c)) {
+        lowerCaseFound = true;
+      }
+      if (i > 0 && password.charAt(i - 1) == c) {
+        return false;
+      }
+    }
+    return password.length() >= 8 && lowerCaseFound && upperCaseFound && digitFound && specialCharFound;
+  }
+}

From c89cc12095cda4131a024765f514208611bc3e65 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Jun 2022 18:14:10 -0700
Subject: [PATCH 1063/2175] Create Minimum Falling Path Sum.java

---
 Medium/Minimum Falling Path Sum.java | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Minimum Falling Path Sum.java

diff --git a/Medium/Minimum Falling Path Sum.java b/Medium/Minimum Falling Path Sum.java
new file mode 100644
index 00000000..040759bf
--- /dev/null
+++ b/Medium/Minimum Falling Path Sum.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public int minFallingPathSum(int[][] matrix) {
+    int minFallingSum = Integer.MAX_VALUE;
+    Integer[][] dp = new Integer[matrix.length][matrix[0].length];
+    for (int i = 0; i < matrix.length; i++) {
+      minFallingSum = Math.min(minFallingSum, findMinFallingPathSumHelper(matrix, 0, i, dp));
+    }
+    return minFallingSum;
+  }
+  
+  private int findMinFallingPathSumHelper(int[][] matrix, int row, int col, Integer[][] dp) {
+    if (col < 0 || col == matrix.length) {
+      return Integer.MAX_VALUE;
+    }
+    if (row == matrix.length - 1) {
+      return matrix[row][col];
+    }
+    if (dp[row][col] != null) {
+      return dp[row][col];
+    }
+    int leftSum = findMinFallingPathSumHelper(matrix, row + 1, col, dp);
+    int middleSum = findMinFallingPathSumHelper(matrix, row + 1, col + 1, dp);
+    int rightSum = findMinFallingPathSumHelper(matrix, row + 1, col - 1, dp);
+    dp[row][col] = Math.min(leftSum, Math.min(middleSum, rightSum)) + matrix[row][col];
+    return dp[row][col];
+  }
+}

From ca8e4f1d632d877e8732bb1fd834fa66095c1e9e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Jun 2022 18:20:04 -0700
Subject: [PATCH 1064/2175] Create Triangle.java

---
 Medium/Triangle.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Triangle.java

diff --git a/Medium/Triangle.java b/Medium/Triangle.java
new file mode 100644
index 00000000..0d4a8b54
--- /dev/null
+++ b/Medium/Triangle.java
@@ -0,0 +1,19 @@
+class Solution {
+  public int minimumTotal(List<List<Integer>> triangle) {
+    Map<String, Integer> dp = new HashMap<>();
+    return minimumTotalHelper(triangle, dp, 0, 0);
+  }
+  
+  private int minimumTotalHelper(List<List<Integer>> triangle, Map<String, Integer> dp, int row, int col) {
+    String key = row + "|" + col;
+    if (dp.containsKey(key)) {
+      return dp.get(key);
+    }
+    int path = triangle.get(row).get(col);
+    if (row < triangle.size() - 1) {
+      path += Math.min(minimumTotalHelper(triangle, dp, row + 1, col), minimumTotalHelper(triangle, dp, row + 1, col + 1));      
+    }
+    dp.put(key, path);
+    return dp.get(key);
+  }
+}

From aaafe41a57201b0f3219ee0d2caf0687e0ca4e72 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Jun 2022 20:44:56 -0700
Subject: [PATCH 1065/2175] Create Calculate Amount Paid in Taxes.java

---
 Easy/Calculate Amount Paid in Taxes.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Calculate Amount Paid in Taxes.java

diff --git a/Easy/Calculate Amount Paid in Taxes.java b/Easy/Calculate Amount Paid in Taxes.java
new file mode 100644
index 00000000..77ae27e2
--- /dev/null
+++ b/Easy/Calculate Amount Paid in Taxes.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public double calculateTax(int[][] brackets, int income) {
+    if (income == 0) {
+      return 0.0;
+    }
+    double tax = 0.0;
+    int idx = 0;
+    while (idx < brackets.length) {
+      int[] currentBracket = brackets[idx];
+      int amount = idx > 0 ? (Math.min(currentBracket[0], income)) - brackets[idx - 1][0] : Math.min(currentBracket[0], income);
+      double taxPercentage = ((double) currentBracket[1]) / 100;
+      tax += taxPercentage * amount;
+      if (income < currentBracket[0]) {
+        break;
+      }
+      idx++;
+    }
+    return tax;
+  }
+}

From 8f418979035d0c56d664510a4df2e34c3843f6c4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Jun 2022 07:35:52 -0700
Subject: [PATCH 1066/2175] Update Pancake Sorting.java

---
 Medium/Pancake Sorting.java | 63 +++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 35 deletions(-)

diff --git a/Medium/Pancake Sorting.java b/Medium/Pancake Sorting.java
index a390ceb2..b8606b27 100644
--- a/Medium/Pancake Sorting.java	
+++ b/Medium/Pancake Sorting.java	
@@ -1,41 +1,34 @@
 class Solution {
-    public List<Integer> pancakeSort(int[] A) {
-        List<Integer> ans = new ArrayList<>();
-        int[] copy = Arrays.copyOf(A, A.length);
-        int n = A.length - 1;
-        Arrays.sort(A);
-        int greatest = A.length - 1;
-        for (int i = 0; i < A.length; i++) {
-            int idx = findIdx(copy, A[greatest]);
-            flip(copy, idx);
-            ans.add(idx + 1);
-            flip(copy, greatest);
-            ans.add(greatest + 1);
-            greatest--;
+  public List<Integer> pancakeSort(int[] arr) {
+    List<Integer> result = new ArrayList<>();
+    for (int i = arr.length; i > 0; i--) {
+      int idx = findIdx(arr, i);
+      if (idx != i - 1) {
+        if (idx != 0) {
+          result.add(idx + 1);
+          flip(arr, idx + 1);
         }
-
-        return ans;
+        result.add(i);
+        flip(arr, i);
+      }
     }
-
-    private void flip (int[] copy, int idx) {
-        int start = 0;
-        int end = idx;
-        while (start < end) {
-            int temp = copy[start];
-            copy[start] = copy[end];
-            copy[end] = temp;
-            start++;
-            end--;
-        }
+    return result;
+  }
+  
+  private void flip(int[] arr, int k) {
+    for (int i = 0; i < k / 2; i++) {
+      int temp = arr[i];
+      arr[i] = arr[k - i - 1];
+      arr[k - i - 1] = temp;
     }
-
-    private int findIdx (int[] arr, int target) {
-        for (int i = 0; i < arr.length; i++) {
-            if (arr[i] == target) {
-                return i;
-            }
-        }
-
-        return -1;
+  }
+  
+  private int findIdx(int[] arr, int target) {
+    for (int i = 0; i < arr.length; i++) {
+      if (arr[i] == target) {
+        return i;
+      }
     }
+    return -1;
+  }
 }

From ff0fd38ddcc0793388121048d6d3c0c6180519d3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Jun 2022 08:02:15 -0700
Subject: [PATCH 1067/2175] Create Successful Pairs of Spells and Potions.java

---
 ...uccessful Pairs of Spells and Potions.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Successful Pairs of Spells and Potions.java

diff --git a/Medium/Successful Pairs of Spells and Potions.java b/Medium/Successful Pairs of Spells and Potions.java
new file mode 100644
index 00000000..40c459c7
--- /dev/null
+++ b/Medium/Successful Pairs of Spells and Potions.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public int[] successfulPairs(int[] spells, int[] potions, long success) {
+    int[] result = new int[spells.length];
+    Arrays.sort(potions);
+    for (int i = 0; i < spells.length; i++) {
+      int idx = getSuccessIdx(potions, spells[i], success);
+      result[i] = potions.length - idx;
+    }
+    return result;
+  }
+  
+  private int getSuccessIdx(int[] potions, int spell, long success) {
+    int left = 0;
+    int right = potions.length;
+    while (left < right) {
+      int mid = (left + right) / 2;
+      long currSuccess = ((long) potions[mid]) * spell;
+      if (currSuccess >= success) {
+        right = mid;
+      } else {
+        left = mid + 1;
+      }
+    }
+    return left;
+  }
+}

From a02d4b7d30cf40d2d7e745c4c4e32beff32e427d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Jun 2022 09:57:50 -0700
Subject: [PATCH 1068/2175] Update Height Checker.java

---
 Easy/Height Checker.java | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/Easy/Height Checker.java b/Easy/Height Checker.java
index 56949329..97bc01d0 100644
--- a/Easy/Height Checker.java	
+++ b/Easy/Height Checker.java	
@@ -1,13 +1,20 @@
 class Solution {
   public int heightChecker(int[] heights) {
-    int[] copy = Arrays.copyOf(heights, heights.length);
-    Arrays.sort(copy);
-    int count = 0;
-    for (int i = 0; i < heights.length; i++) {
-      if (heights[i] != copy[i]) {
-        count++;
+    int[] frequencies = new int[101];
+    for (int height : heights) {
+      frequencies[height]++;
+    }
+    int currHeight = 1;
+    int mismatchCount = 0;
+    for (int height : heights) {
+      while (frequencies[currHeight] == 0) {
+        currHeight++;
+      }
+      if (currHeight != height) {
+        mismatchCount++;
       }
+      frequencies[currHeight]--;
     }
-    return count;
+    return mismatchCount;
   }
 }

From 7b4790aaf0049dc4191426ff34a115664ab2b42e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Jun 2022 09:59:46 -0700
Subject: [PATCH 1069/2175] Update Long Pressed Name.java

---
 Easy/Long Pressed Name.java | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/Easy/Long Pressed Name.java b/Easy/Long Pressed Name.java
index 48f9e787..3e134aa3 100644
--- a/Easy/Long Pressed Name.java	
+++ b/Easy/Long Pressed Name.java	
@@ -1,22 +1,27 @@
 class Solution {
   public boolean isLongPressedName(String name, String typed) {
-    int nameIdx = 0;
-    int typeIdx = 0;
-    int nameLen = name.length();
-    int typeLen = typed.length();
-    while (nameIdx < nameLen && typeIdx < typeLen) {
-      if (name.charAt(nameIdx) != typed.charAt(typeIdx)) {
+    int idxName = 0;
+    int idxTyped = 0;
+    while (idxName < name.length() && idxTyped < typed.length()) {
+      if (name.charAt(idxName) != typed.charAt(idxTyped)) {
         return false;
       }
-      while (nameIdx < nameLen && typeIdx < typeLen && name.charAt(nameIdx) == typed.charAt(typeIdx)) {
-        nameIdx++;
-        typeIdx++;
+      char c = name.charAt(idxName);
+      int nameFreq = 0;
+      while (idxName < name.length() && name.charAt(idxName) == c) {
+        idxName++;
+        nameFreq++;
       }
-      char prev = name.charAt(nameIdx - 1);
-      while (typeIdx < typeLen && typed.charAt(typeIdx) == prev) {
-        typeIdx++;
+      c = typed.charAt(idxTyped);
+      int typedFreq = 0;
+      while (idxTyped < typed.length() && typed.charAt(idxTyped) == c) {
+        idxTyped++;
+        typedFreq++;
+      }
+      if (nameFreq > typedFreq) {
+        return false;
       }
     }
-    return nameIdx == nameLen && typeIdx == typeLen;
+    return idxName == name.length() && idxTyped == typed.length();
   }
 }

From 5845b8f188f3657e090386bdaa10f0cf0f0a98d3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Jun 2022 13:32:07 -0700
Subject: [PATCH 1070/2175] Update Student Attendance Record I.java

---
 Easy/Student Attendance Record I.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Easy/Student Attendance Record I.java b/Easy/Student Attendance Record I.java
index 0278cb49..75021837 100644
--- a/Easy/Student Attendance Record I.java	
+++ b/Easy/Student Attendance Record I.java	
@@ -1,16 +1,16 @@
 class Solution {
   public boolean checkRecord(String s) {
     int absentCount = 0;
-    for (int i = 0; i< s.length(); i++) {
-      if (s.charAt(i) == 'A') {
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (c == 'A') {
         absentCount++;
-      }
-      else if (s.charAt(i) == 'L') {
-        if (i + 1 < s.length() && i + 2 < s.length() && s.charAt(i + 1) == 'L' && s.charAt(i + 2) == 'L') {
+      } else if (c == 'L') {
+        if (i > 1 && s.charAt(i - 1) == 'L' && s.charAt(i - 2) == 'L') {
           return false;
         }
       }
     }
-    return absentCount <= 1;
+    return absentCount < 2;
   }
 }

From b17cdbcc45c0d7f96b4aea84b21a4a181363b390 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Jun 2022 13:33:38 -0700
Subject: [PATCH 1071/2175] Update Network Delay Time.java

---
 Medium/Network Delay Time.java | 47 ++++++++++++++++++----------------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/Medium/Network Delay Time.java b/Medium/Network Delay Time.java
index 90ddb22c..2ee2990a 100644
--- a/Medium/Network Delay Time.java	
+++ b/Medium/Network Delay Time.java	
@@ -1,32 +1,35 @@
 class Solution {
   public int networkDelayTime(int[][] times, int n, int k) {
-    // Mapping from node to all outgoing edges alongside weight of each edge
-    Map<Integer, List<int[]>> map = new HashMap<>();
+    Map<Integer, List<TimeNode>> map = new HashMap<>();
     for (int[] time : times) {
-      map.computeIfAbsent(time[0], j -> new ArrayList<>()).add(new int[] {time[1], time[2]});
+      map.computeIfAbsent(time[0], j -> new ArrayList<>()).add(new TimeNode(time[1], time[2]));
     }
-    // Min heap in order of edge weight
-    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(o -> o[0]));
-    priorityQueue.add(new int[] {0, k});
+    PriorityQueue<TimeNode> pq = new PriorityQueue<>(Comparator.comparingInt(o -> o.time));
+    pq.add(new TimeNode(k, 0));
+    int maxTime = 0;
     Set<Integer> visited = new HashSet<>();
-    int totalTime = 0;
-    while (!priorityQueue.isEmpty()) {
-      int[] removed = priorityQueue.poll();
-      int currNode = removed[1];
-      int edgeWeight = removed[0];
-      if (visited.contains(currNode)) {
-        continue;
-      }
-      visited.add(currNode);
-      totalTime = Math.max(totalTime, edgeWeight);
-      for (int[] neighbor : map.getOrDefault(removed[1], new ArrayList<>())) {
-        int neighborNode = neighbor[0];
-        int neighborEdgeWeight = neighbor[1];
-        if (!visited.contains(neighborNode)) {
-          priorityQueue.add(new int[] {neighborEdgeWeight + edgeWeight, neighborNode});
+    visited.add(k);
+    while (!pq.isEmpty() && visited.size() < n) {
+      TimeNode removed = pq.remove();
+      visited.add(removed.node);
+      maxTime = Math.max(maxTime, removed.time);
+      for (TimeNode conn : map.getOrDefault(removed.node, new ArrayList<>())) {
+        if (visited.contains(conn.node)) {
+          continue;
         }
+        pq.add(new TimeNode(conn.node, removed.time + conn.time));
       }
     }
-    return visited.size() == n ? totalTime : -1;
+    return visited.size() == n ? maxTime : -1;
+  }
+  
+  class TimeNode {
+    int node;
+    int time;
+    
+    public TimeNode(int node, int time) {
+      this.node = node;
+      this.time = time;
+    }
   }
 }

From cd4bc6c1b12b257c6aee3880d46d26429871d541 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Jun 2022 20:09:39 -0700
Subject: [PATCH 1072/2175] Update Delete Operation for Two Strings.java

---
 Medium/Delete Operation for Two Strings.java | 40 +++++++++-----------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/Medium/Delete Operation for Two Strings.java b/Medium/Delete Operation for Two Strings.java
index 8e8f1ea5..f5e48340 100644
--- a/Medium/Delete Operation for Two Strings.java	
+++ b/Medium/Delete Operation for Two Strings.java	
@@ -1,25 +1,21 @@
 class Solution {
-    public int minDistance(String word1, String word2) {
-        int[][] memo = new int[word1.length() + 1][word2.length() + 1];
-        for (int i = 0; i <= word1.length(); i++) {
-            for (int j = 0; j <= word2.length(); j++) {
-                if (i == 0) {
-                    memo[i][j] = j;
-                }
-                else if (j == 0) {
-                    memo[i][j] = i;
-                }
-                else if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
-                    memo[i][j] = memo[i - 1][j - 1];
-                }
-                else {
-                    memo[i][j] = Math.min(Math.min(memo[i - 1][j - 1] + 2, memo[i - 1][j] + 1), 
-                                          memo[i][j - 1] + 1);
-                }
-            }
-        }
-        
-        return memo[word1.length()][word2.length()];
+  public int minDistance(String word1, String word2) {
+    int[][] dp = new int[word1.length() + 1][word2.length() + 1];
+    return word1.length() + word2.length() - 2 * longestCommonSubsequence(word1, word2, word1.length(), word2.length(), dp);
+  }
+  
+  private int longestCommonSubsequence(String word1, String word2, int m, int n, int[][] dp) {
+    if (m == 0 || n == 0) {
+      return 0;
     }
+    if (dp[m][n] > 0) {
+      return dp[m][n];
+    }
+    if (word1.charAt(m - 1) == word2.charAt(n - 1)) {
+      dp[m][n] = 1 + longestCommonSubsequence(word1, word2, m - 1, n - 1, dp);
+    } else {
+      dp[m][n] = Math.max(longestCommonSubsequence(word1, word2, m - 1, n, dp), longestCommonSubsequence(word1, word2, m, n - 1, dp));
+    }
+    return dp[m][n];
+  }
 }
-

From 80e3f0cf8a0867461a0fb633ae37751055f8291b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 14 Jun 2022 15:25:09 -0700
Subject: [PATCH 1073/2175] Update Flower Planting With No Adjacent.java

---
 Easy/Flower Planting With No Adjacent.java | 31 ++++++++++------------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/Easy/Flower Planting With No Adjacent.java b/Easy/Flower Planting With No Adjacent.java
index 70ea74de..88bf6a8b 100644
--- a/Easy/Flower Planting With No Adjacent.java	
+++ b/Easy/Flower Planting With No Adjacent.java	
@@ -1,25 +1,22 @@
 class Solution {
-  public int[] gardenNoAdj(int N, int[][] paths) {
-    Map<Integer, List<Integer>> map = new HashMap<>();
+  public int[] gardenNoAdj(int n, int[][] paths) {
+    Map<Integer, Set<Integer>> map = new HashMap<>();
     for (int[] path : paths) {
-      map.computeIfAbsent(path[0], k -> new ArrayList<>()).add(path[1]);
-      map.computeIfAbsent(path[1], k -> new ArrayList<>()).add(path[0]);
+      map.computeIfAbsent(path[0], k -> new HashSet<>()).add(path[1]);
+      map.computeIfAbsent(path[1], k -> new HashSet<>()).add(path[0]);
     }
-    int[] ans = new int[N];
-    for (int i = 0; i < N; i++) {
-      Set<Integer> neighbourPlant = new HashSet<>();
-      for (Integer neighbour : map.getOrDefault(i + 1, new ArrayList<>())) {
-        if (ans[neighbour - 1] != 0) {
-          neighbourPlant.add(ans[neighbour - 1]);
-        }
-      }
-      for (int j = 1; j <= 4; j++) {
-        if (!neighbourPlant.contains(j)) {
-          ans[i] = j;
-          break;
+    int[] result = new int[n];
+    for (int i = 1; i <= n; i++) {
+      int[] colors = new int[5];
+      for (int neighbor : map.getOrDefault(i, new HashSet<>())) {
+        colors[result[neighbor - 1]] = 1;
+      }      
+      for (int c = 4; c > 0; c--) {
+        if (colors[c] != 1) {
+          result[i - 1] = c;
         }
       }
     }
-    return ans;
+    return result;
   }
 }

From 0c750753c6e5a0309fe56b83e6f368778dd00609 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 15 Jun 2022 07:16:49 -0700
Subject: [PATCH 1074/2175] Update Longest Continuous Increasing
 Subsequence.java

---
 ...est Continuous Increasing Subsequence.java | 22 ++++++++-----------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/Easy/Longest Continuous Increasing Subsequence.java b/Easy/Longest Continuous Increasing Subsequence.java
index 77d31e56..f0a73d6a 100644
--- a/Easy/Longest Continuous Increasing Subsequence.java	
+++ b/Easy/Longest Continuous Increasing Subsequence.java	
@@ -1,20 +1,16 @@
 class Solution {
   public int findLengthOfLCIS(int[] nums) {
-    if (nums.length == 0) {
-      return 0;
-    }
     int maxLength = 1;
-    int currCount = 1;
-    int n = nums.length;
-    for (int i = 1; i < n; i++) {
-      if (nums[i] > nums[i - 1]) {
-        currCount++;
-      }
-      else {
-        maxLength = Math.max(maxLength, currCount);
-        currCount = 1;
+    int idx = 0;
+    while (idx < nums.length) {
+      int count = 1;
+      while (idx < nums.length && idx + 1 < nums.length && nums[idx] < nums[idx + 1]) {
+        idx++;
+        count++;
       }
+      maxLength = Math.max(maxLength, count);
+      idx++;
     }
-    return Math.max(maxLength, currCount);
+    return maxLength;
   }
 }

From 71611f06830b1b0d3bcba4a0d733160f7f2fdca4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 15 Jun 2022 07:36:59 -0700
Subject: [PATCH 1075/2175] Update Longest Increasing Subsequence.java

---
 Medium/Longest Increasing Subsequence.java | 32 ++++++++++------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/Medium/Longest Increasing Subsequence.java b/Medium/Longest Increasing Subsequence.java
index fd5f299e..a4607634 100644
--- a/Medium/Longest Increasing Subsequence.java	
+++ b/Medium/Longest Increasing Subsequence.java	
@@ -1,21 +1,19 @@
 class Solution {
-    public int lengthOfLIS(int[] nums) {
-        int[] dp = new int[nums.length];
-        Arrays.fill(dp, 1);
-        
-        for (int i = 1; i < nums.length; i ++) {
-            for (int j = 0; j < i; j++) {
-                if (nums[j] < nums[i]) {
-                    dp[i] = Math.max(dp[i], dp[j] + 1);
-                }
-            }
+  public int lengthOfLIS(int[] nums) {
+    List<Integer> subsequence = new ArrayList<>();
+    subsequence.add(nums[0]);
+    for (int i = 1; i < nums.length; i++) {
+      int currNum = nums[i];
+      if (currNum > subsequence.get(subsequence.size() - 1)) {
+        subsequence.add(currNum);
+      } else {
+        int idx = 0;
+        while (currNum > subsequence.get(idx)) {
+          idx++;
         }
-        
-        int max = Integer.MIN_VALUE;
-        for (int num : dp) {
-            max = Math.max(num, max);
-        }
-        
-        return max == Integer.MIN_VALUE ? 0 : max;
+        subsequence.set(idx, currNum);
+      }
     }
+    return subsequence.size();
+  }
 }

From feb690603ffac01ff8d5c53a972dab59e9131bee Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 15 Jun 2022 08:20:41 -0700
Subject: [PATCH 1076/2175] Create Longest String Chain.java

---
 Medium/Longest String Chain.java | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Longest String Chain.java

diff --git a/Medium/Longest String Chain.java b/Medium/Longest String Chain.java
new file mode 100644
index 00000000..17d14f0c
--- /dev/null
+++ b/Medium/Longest String Chain.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int longestStrChain(String[] words) {
+    Map<String, Integer> dp = new HashMap<>();
+    Set<String> wordSet = Arrays.stream(words).collect(Collectors.toSet());
+    int maxLength = 0;
+    for (String word : words) {
+      maxLength = Math.max(maxLength, dfs(wordSet, dp, word));
+    }
+    return maxLength;
+  }
+  
+  private int dfs(Set<String> wordSet, Map<String, Integer> dp, String currWord) {
+    if (dp.containsKey(currWord)) {
+      return dp.get(currWord);
+    }
+    int maxLength = 1;
+    StringBuilder sb = new StringBuilder(currWord);
+    for (int i = 0; i < currWord.length(); i++) {
+      sb.deleteCharAt(i);
+      String newWord = sb.toString();
+      if (wordSet.contains(newWord)) {
+        maxLength = Math.max(maxLength, 1 + dfs(wordSet, dp, newWord));
+      }
+      sb.insert(i, currWord.charAt(i));
+    }
+    dp.put(currWord, maxLength);
+    return dp.get(currWord);
+  }
+}

From e1bdbc475b365a025956b46fde2032ebe244134f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 15 Jun 2022 16:07:17 -0700
Subject: [PATCH 1077/2175] Update Two Sum Less Than K.java

---
 Easy/Two Sum Less Than K.java | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/Easy/Two Sum Less Than K.java b/Easy/Two Sum Less Than K.java
index 7a74f60d..5acfd8dc 100644
--- a/Easy/Two Sum Less Than K.java	
+++ b/Easy/Two Sum Less Than K.java	
@@ -1,17 +1,22 @@
 class Solution {
-  public int twoSumLessThanK(int[] A, int K) {
-    int maxSum = -1;
-    TreeSet<Integer> set = new TreeSet<>();
-    for (int i = 0; i < A.length; i++) {
-      int diff = K - A[i];
-      if (diff > 0) {
-        Integer half = set.lower(diff);
-        if (half != null) {
-          maxSum = Math.max(maxSum, A[i] + half);
+  public int twoSumLessThanK(int[] nums, int k) {
+    int[] counter = new int[1001];
+    for (int num : nums) {
+      counter[num]++;
+    }
+    int result = -1;
+    int left = 1;
+    int right = 1000;
+    while (left <= right) {
+      if (left + right >= k || counter[right] == 0) {
+        right--;
+      } else {
+        if (counter[left] > (left == right ? 1 : 0)) {
+          result = Math.max(result, left + right);
         }
+        left++;
       }
-      set.add(A[i]);
     }
-    return maxSum;
+    return result;
   }
 }

From e2ad64ec26587976060a5265f2a99a5a5a11d177 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 16 Jun 2022 10:54:44 -0700
Subject: [PATCH 1078/2175] Create Fair Distribution of Cookies.java

---
 Medium/Fair Distribution of Cookies.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Fair Distribution of Cookies.java

diff --git a/Medium/Fair Distribution of Cookies.java b/Medium/Fair Distribution of Cookies.java
new file mode 100644
index 00000000..ad4b0f94
--- /dev/null
+++ b/Medium/Fair Distribution of Cookies.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int distributeCookies(int[] cookies, int k) {
+    int[] share = new int[k];
+    return helper(cookies, share, 0);
+  }
+  
+  private int helper(int[] cookies, int[] share, int idx) {
+    if (idx == cookies.length) {
+      int maxShare = share[0];
+      for (int s : share) {
+        maxShare = Math.max(s, maxShare);
+      }
+      return maxShare;
+    }
+    int result = Integer.MAX_VALUE;
+    for(int i = 0; i < share.length; i++){
+      share[i] += cookies[idx];
+      result = Math.min(result, helper(cookies, share, idx + 1));
+      share[i] -= cookies[idx];
+    }
+    return result;
+  }
+}

From 23ea9793ce0da1005d6a181d1e7bf1f6cee34d6c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 17 Jun 2022 08:12:16 -0700
Subject: [PATCH 1079/2175] Create Binary Tree Cameras.java

---
 Hard/Binary Tree Cameras.java | 45 +++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 Hard/Binary Tree Cameras.java

diff --git a/Hard/Binary Tree Cameras.java b/Hard/Binary Tree Cameras.java
new file mode 100644
index 00000000..f87825e6
--- /dev/null
+++ b/Hard/Binary Tree Cameras.java	
@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  private final int NOT_MONITORED = 0;
+  private final int MONITORED_NOCAM = 1;
+  private final int MONITORED_WITHCAM = 2;
+
+  public int minCameraCover(TreeNode root) {
+    if (root == null) {
+      return 0;
+    }
+    int[] cameras = {0};
+    int top = dfs(root, cameras);
+    return cameras[0] + (top == NOT_MONITORED ? 1 : 0);
+  }
+
+  private int dfs(TreeNode root, int[] cameras) {
+    if (root == null) {
+      return MONITORED_NOCAM;
+    }
+    int left = dfs(root.left, cameras);
+    int right = dfs(root.right, cameras);
+    if (left == MONITORED_NOCAM && right == MONITORED_NOCAM) {
+      return NOT_MONITORED;
+    } else if (left == NOT_MONITORED || right == NOT_MONITORED) {
+      cameras[0]++;
+      return MONITORED_WITHCAM;
+    } else {
+      return MONITORED_NOCAM;
+    }
+  }
+}

From 8e44e4ee8ae8ef3d8035bbe2d2363443cd8ca33c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 17 Jun 2022 12:21:49 -0700
Subject: [PATCH 1080/2175] Update Design Circular Deque.java

---
 Medium/Design Circular Deque.java | 123 +++++++++---------------------
 1 file changed, 34 insertions(+), 89 deletions(-)

diff --git a/Medium/Design Circular Deque.java b/Medium/Design Circular Deque.java
index 38b8650c..56c261e5 100644
--- a/Medium/Design Circular Deque.java	
+++ b/Medium/Design Circular Deque.java	
@@ -1,117 +1,62 @@
-class MyCircularDeque {
-  DequeNode head;
-  DequeNode tail;
-  int k;
-  int currCapacity;
+class MyCircularQueue {
+  private int[] queue;
+  private int valueCursor;
+  private int emptyCursor;
 
-  /** Initialize your data structure here. Set the size of the deque to be k. */
-  public MyCircularDeque(int k) {
-    currCapacity = 0;
-    this.k = k;
-    head = new DequeNode(-1);
-    tail = new DequeNode(-1);
-    head.front = tail;
-    tail.back = head;
+  public MyCircularQueue(int k) {
+    this.queue = new int[k];
+    Arrays.fill(queue, -1);
+    this.emptyCursor = 0;
+    this.valueCursor = 0;
   }
 
-  /** Adds an item at the front of Deque. Return true if the operation is successful. */
-  public boolean insertFront(int value) {
-    if (isFull()) {
+  public boolean enQueue(int value) {
+    if (this.queue[this.emptyCursor] != -1) {
       return false;
     }
-    DequeNode node = new DequeNode(value);
-    node.front = head.front;
-    head.front.back = node;
-    node.back = head;
-    head.front = node;
-    currCapacity++;
-    return true;
-  }
-
-  /** Adds an item at the rear of Deque. Return true if the operation is successful. */
-  public boolean insertLast(int value) {
-    if (isFull()) {
-      return false;
+    this.queue[this.emptyCursor++] = value;
+    if (this.emptyCursor == this.queue.length) {
+      this.emptyCursor = 0;
     }
-    DequeNode node = new DequeNode(value);
-    node.front = tail;
-    node.back = tail.back;
-    tail.back.front = node;
-    tail.back = node;
-    currCapacity++;
     return true;
   }
 
-  /** Deletes an item from the front of Deque. Return true if the operation is successful. */
-  public boolean deleteFront() {
-    if (isEmpty()) {
+  public boolean deQueue() {
+    if (this.queue[this.valueCursor] == -1) {
       return false;
     }
-    DequeNode next = head.front.front;
-    head.front = next;
-    next.back = head;
-    currCapacity--;
-    return true;
-  }
-
-  /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
-  public boolean deleteLast() {
-    if (isEmpty()) {
-      return false;
+    this.queue[this.valueCursor++] = -1;
+    if (this.valueCursor == this.queue.length) {
+      this.valueCursor = 0;
     }
-    DequeNode prev = tail.back.back;
-    tail.back = prev;
-    prev.front = tail;
-    currCapacity--;
     return true;
   }
 
-  /** Get the front item from the deque. */
-  public int getFront() {
-    if (isEmpty()) {
-      return -1;
-    }
-    return head.front.val;
+  public int Front() {
+    return this.queue[this.valueCursor];
   }
 
-  /** Get the last item from the deque. */
-  public int getRear() {
-    if (isEmpty()) {
-      return -1;
-    }
-    return tail.back.val;
+  public int Rear() {
+    int idx = this.emptyCursor == 0 ? this.queue.length - 1 : this.emptyCursor - 1;
+    return this.queue[idx];
   }
 
-  /** Checks whether the circular deque is empty or not. */
   public boolean isEmpty() {
-    return currCapacity == 0;
+    return this.queue[this.valueCursor] == -1;
   }
 
-  /** Checks whether the circular deque is full or not. */
   public boolean isFull() {
-    return currCapacity == k;
-  }
-}
-
-class DequeNode {
-  int val;
-  DequeNode front;
-  DequeNode back;
-  
-  public DequeNode(int val) {
-    this.val = val;
+    return this.queue[this.emptyCursor] != -1;
   }
 }
 
 /**
- * Your MyCircularDeque object will be instantiated and called as such:
- * MyCircularDeque obj = new MyCircularDeque(k);
- * boolean param_1 = obj.insertFront(value);
- * boolean param_2 = obj.insertLast(value);
- * boolean param_3 = obj.deleteFront();
- * boolean param_4 = obj.deleteLast();
- * int param_5 = obj.getFront();
- * int param_6 = obj.getRear();
- * boolean param_7 = obj.isEmpty();
- * boolean param_8 = obj.isFull();
+ * Your MyCircularQueue object will be instantiated and called as such:
+ * MyCircularQueue obj = new MyCircularQueue(k);
+ * boolean param_1 = obj.enQueue(value);
+ * boolean param_2 = obj.deQueue();
+ * int param_3 = obj.Front();
+ * int param_4 = obj.Rear();
+ * boolean param_5 = obj.isEmpty();
+ * boolean param_6 = obj.isFull();
  */

From 4a5ebc891d07a8a959f93a71bd11855b75483bf6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 17 Jun 2022 13:24:16 -0700
Subject: [PATCH 1081/2175] Update Web Crawler.java

---
 Medium/Web Crawler.java | 42 +++++++++++++++++++++--------------------
 1 file changed, 22 insertions(+), 20 deletions(-)

diff --git a/Medium/Web Crawler.java b/Medium/Web Crawler.java
index 2eafccb7..57737330 100644
--- a/Medium/Web Crawler.java	
+++ b/Medium/Web Crawler.java	
@@ -5,27 +5,29 @@
  *     public List<String> getUrls(String url) {}
  * }
  */
+
 class Solution {
-    public List<String> crawl(String startUrl, HtmlParser htmlParser) {
-        Set<String> visited = new HashSet<>();
-        Stack<String> stack = new Stack<>();
-        stack.push(startUrl);
-        String hostname = getHostname(startUrl);
-        while(!stack.isEmpty()) {
-            String popped = stack.pop();
-            visited.add(popped);
-            List<String> connectedUrls = htmlParser.getUrls(popped);
-            for (String url : connectedUrls) {
-                if (!visited.contains(url) && url.contains(hostname)) {
-                    stack.push(url);
-                }
-            }
+  public List<String> crawl(String startUrl, HtmlParser htmlParser) {
+    int startIdx = startUrl.indexOf("//") + 2;
+    int endIdx = startUrl.indexOf("/", startIdx) == -1 ? startUrl.length() : startUrl.indexOf("/", startIdx);
+    String domain = startUrl.substring(0, endIdx);
+    Set<String> visitedUrls = new HashSet<>();
+    Queue<String> queue = new LinkedList<>();
+    queue.add(startUrl);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        String removed = queue.remove();
+        visitedUrls.add(removed);
+        List<String> urls = htmlParser.getUrls(removed);
+        for (String url : urls) {
+          if (url.startsWith(domain) && !visitedUrls.contains(url)) {
+            visitedUrls.add(url);
+            queue.add(url);
+          }
         }
-        return new ArrayList<>(visited);
-    }
-    
-    private String getHostname(String url) {
-        String[] splits = url.split("/");
-        return splits[2];
+      }
     }
+    return new ArrayList<>(visitedUrls);
+  }
 }

From 069f1dce059f9a382b57a0da69ddafd79f26a4db Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 17 Jun 2022 15:41:49 -0700
Subject: [PATCH 1082/2175] Update Graph Valid Tree.java

---
 Medium/Graph Valid Tree.java | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/Medium/Graph Valid Tree.java b/Medium/Graph Valid Tree.java
index 1c4aaa48..658608a4 100644
--- a/Medium/Graph Valid Tree.java	
+++ b/Medium/Graph Valid Tree.java	
@@ -1,19 +1,27 @@
 class Solution {
   public boolean validTree(int n, int[][] edges) {
-    int[] nums = new int[n];
-    Arrays.fill(nums, -1);
+    Map<Integer, Set<Integer>> map = new HashMap<>();
     for (int[] edge : edges) {
-      int rootOne = find(nums, edge[0]);
-      int rootTwo = find(nums, edge[1]);
-      if (rootOne == rootTwo) {
-        return false;
+      map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+      map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    }
+    Map<Integer, Integer> parent = new HashMap<>();
+    parent.put(0, -1);
+    Stack<Integer> stack = new Stack<>();
+    stack.push(0);
+    while (!stack.isEmpty()) {
+      int node = stack.pop();
+      for (int neighbor : map.getOrDefault(node, new HashSet<>())) {
+        if (parent.get(node) == neighbor) {
+          continue;
+        }
+        if (parent.containsKey(neighbor)) {
+          return false;
+        }
+        stack.push(neighbor);
+        parent.put(neighbor, node);
       }
-      nums[rootOne] = rootTwo;
     }
-    return edges.length == n - 1;
-  }
-  
-  private int find(int[] nums, int n) {
-    return nums[n] == -1 ? n : find(nums, nums[n]);
+    return parent.size() == n;
   }
 }

From 350df3288cabeec3ed602f8b0b5d140f79ae4691 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Jun 2022 08:29:19 -0700
Subject: [PATCH 1083/2175] Update Prefix and Suffix Search.java

---
 Hard/Prefix and Suffix Search.java | 75 ++++++++++++------------------
 1 file changed, 31 insertions(+), 44 deletions(-)

diff --git a/Hard/Prefix and Suffix Search.java b/Hard/Prefix and Suffix Search.java
index 4a791c66..e7778aff 100644
--- a/Hard/Prefix and Suffix Search.java	
+++ b/Hard/Prefix and Suffix Search.java	
@@ -1,61 +1,48 @@
 class WordFilter {
 
-  Node root;
-  Map<String, Integer> weightMap;
+  private TrieNode root;
+  
   public WordFilter(String[] words) {
-    root = new Node('-');
-    weightMap = new HashMap<>();
+    this.root = new TrieNode();
     for (int i = 0; i < words.length; i++) {
-      root.words.add(words[i]);
-      addWord(words[i], 0, root);
-      weightMap.put(words[i], i);
-    }
-  }
-  
-  private void addWord(String word, int idx, Node curr) {
-    if (idx == word.length()) {
-      return;
+      indexWord(words[i], i);
     }
-    char c = word.charAt(idx);
-    if (!curr.children.containsKey(c)) {
-      curr.children.put(c, new Node(c));
-    }
-    curr = curr.children.get(c);
-    curr.words.add(word);
-    addWord(word, idx + 1, curr);
   }
 
   public int f(String prefix, String suffix) {
-    Node curr = root;
-    if (prefix.length() != 0) {
-      for (char c : prefix.toCharArray()) {
-        if (!curr.children.containsKey(c)) {
-          return -1;
-        }
-        curr = curr.children.get(c);
+    TrieNode curr = root;
+    for (char c : (suffix + "{" + prefix).toCharArray()) {
+      if (curr.children[c - 'a'] == null) {
+        return -1;
       }
+      curr = curr.children[c - 'a'];
     }
-    int ans = -1;
-    for (String word : curr.words) {
-      if (suffix.length() == 0 || word.endsWith(suffix)) {
-        ans = Math.max(ans, weightMap.get(word));
+    return curr.maxIdx;
+  }
+
+  private void indexWord(String word, int idx) {
+    for (int i = word.length() - 1; i >= 0; i--) {
+      String suffixAndPrefix = word.substring(i, word.length()) + "{" + word;
+      TrieNode curr = root;
+      for (char c : suffixAndPrefix.toCharArray()) {
+        if (curr.children[c - 'a'] == null) {
+          curr.children[c - 'a'] = new TrieNode();
+        }
+        curr = curr.children[c - 'a'];
+        curr.maxIdx = idx;
       }
     }
-    return ans;
   }
-}
-
-
-class Node {
-  char c;
-  Map<Character, Node> children;
-  Set<String> words;
   
-  public Node(char c) {
-    this.c = c;
-    children = new HashMap<>();
-    words = new HashSet<>();
-  } 
+  
+  private class TrieNode {
+    TrieNode[] children;
+    int maxIdx;    
+    public TrieNode() {
+      this.children = new TrieNode[27];
+      this.maxIdx = 0;
+    }
+  }
 }
 
 /**

From eb856abb2efd3419d527e7cf9d4971658e311527 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Jun 2022 16:50:40 -0700
Subject: [PATCH 1084/2175] Update Isomorphic Strings.java

---
 Easy/Isomorphic Strings.java | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/Easy/Isomorphic Strings.java b/Easy/Isomorphic Strings.java
index 365f4ce6..6b870650 100644
--- a/Easy/Isomorphic Strings.java	
+++ b/Easy/Isomorphic Strings.java	
@@ -1,10 +1,12 @@
 class Solution {
-    public boolean isIsomorphic(String s1, String s2) {
-        int[] m = new int[512];
-        for (int i = 0; i < s1.length(); i++) {
-            if (m[s1.charAt(i)] != m[s2.charAt(i)+256]) return false;
-            m[s1.charAt(i)] = m[s2.charAt(i)+256] = i+1;
-        }
-        return true;
+  public boolean isIsomorphic(String s, String t) {
+    int[] position = new int[512];
+    for (int i = 0; i < s.length(); i++) {
+      if (position[s.charAt(i)] != position[t.charAt(i) + 256]) {
+        return false;
+      }
+      position[s.charAt(i)] = position[t.charAt(i) + 256] = i + 1;
     }
+    return true;
+  }
 }

From c198cb91f5fe6bd60306de3c8023031de4c7d280 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Jun 2022 17:02:00 -0700
Subject: [PATCH 1085/2175] Update Maximum Average Subarray I.java

---
 Easy/Maximum Average Subarray I.java | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/Easy/Maximum Average Subarray I.java b/Easy/Maximum Average Subarray I.java
index 7ac37a5c..bdd6206e 100644
--- a/Easy/Maximum Average Subarray I.java	
+++ b/Easy/Maximum Average Subarray I.java	
@@ -1,17 +1,15 @@
 class Solution {
   public double findMaxAverage(int[] nums, int k) {
-    Double max = null;
     double sum = 0;
-    for (int i = 0; i < k - 1; i++) {
+    for (int i = 0; i < k; i++) {
       sum += nums[i];
     }
-    int start = 0;
-    for (int i = k - 1; i < nums.length; i++) {
+    double maxAverage = sum / k;
+    for (int i = k; i < nums.length; i++) {
+      sum -= nums[i - k];
       sum += nums[i];
-      double avg = sum / k;
-      max = max == null ? avg : Math.max(max, avg);
-      sum -= nums[start++];
+      maxAverage = Math.max(maxAverage, sum / k);
     }
-    return max;
+    return maxAverage;
   }
 }

From 9b695de4fbe2996adb94623cd6b934bb28624eb5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Jun 2022 17:06:46 -0700
Subject: [PATCH 1086/2175] Update Contains Duplicate II.java

---
 Easy/Contains Duplicate II.java | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/Easy/Contains Duplicate II.java b/Easy/Contains Duplicate II.java
index 579e6ae4..1200875f 100644
--- a/Easy/Contains Duplicate II.java	
+++ b/Easy/Contains Duplicate II.java	
@@ -1,14 +1,12 @@
 class Solution {
-    public boolean containsNearbyDuplicate(int[] nums, int k) {
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int i=0;i<nums.length;i++) {
-            if (map.containsKey(nums[i])) {
-                if (Math.abs(map.get(nums[i]) - i) <= k) {
-                    return true;
-                }
-            }
-            map.put(nums[i], i);
-        }
-        return false;
+  public boolean containsNearbyDuplicate(int[] nums, int k) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+      if (map.containsKey(nums[i]) && Math.abs(map.get(nums[i]) - i) <= k) {
+        return true;
+      }
+      map.put(nums[i], i);
     }
+    return false;
+  }
 }

From 2ec2fe2c41715a80e114d7ebcb12c37dfed557b6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 Jun 2022 07:27:24 -0700
Subject: [PATCH 1087/2175] Update Search Suggestions System.java

---
 Medium/Search Suggestions System.java | 81 +++++++++++----------------
 1 file changed, 34 insertions(+), 47 deletions(-)

diff --git a/Medium/Search Suggestions System.java b/Medium/Search Suggestions System.java
index 465bde7f..47458964 100644
--- a/Medium/Search Suggestions System.java	
+++ b/Medium/Search Suggestions System.java	
@@ -1,59 +1,46 @@
 class Solution {
   public List<List<String>> suggestedProducts(String[] products, String searchWord) {
-    Node root = new Node('-');
-    for (String product : products) {
-      addProduct(product, root);
+    TrieNode root = new TrieNode();
+    for (String prod : products) {
+      TrieNode curr = root;
+      for (char c : prod.toCharArray()) {
+        if (curr.children[c - 'a'] == null) {
+          curr.children[c - 'a'] = new TrieNode();
+        }
+        curr = curr.children[c - 'a'];
+        curr.matchingProducts.add(prod);
+      }
     }
-    List<List<String>> list = new ArrayList<>();
-    Node curr = root;
-    boolean notFound = false;
+    List<List<String>> result = new ArrayList<>();
+    TrieNode curr = root;
     for (char c : searchWord.toCharArray()) {
-      if (notFound) {
-        list.add(new ArrayList<>());
-      }
-      else {
-        if (!curr.children.containsKey(c)) {
-          notFound = true;
-          list.add(new ArrayList<>());
-          continue;
+      if (curr == null) {
+        result.add(new ArrayList<>());
+      } else {
+        if (curr.children[c - 'a'] == null) {
+          curr = null;
+          result.add(new ArrayList<>());
+        } else {
+          curr = curr.children[c - 'a'];
+          PriorityQueue<String> currMatchingProductsQueue = new PriorityQueue<>(curr.matchingProducts);
+          List<String> currMatchingProducts = new ArrayList<>();
+          while (!currMatchingProductsQueue.isEmpty() && currMatchingProducts.size() < 3) {
+            currMatchingProducts.add(currMatchingProductsQueue.poll());
+          }
+          result.add(currMatchingProducts);
         }
-        curr = curr.children.get(c);
-        List<String> temp = new ArrayList<>();
-        PriorityQueue<String> words = new PriorityQueue<>(curr.possibleWords);
-        for (int i = 0; i < 3 && !words.isEmpty(); i++) {
-          temp.add(words.poll());
-        }
-        Collections.reverse(temp);
-        list.add(temp);
       }
     }
-    return list;
+    return result;
   }
   
-  private void addProduct(String product, Node root) {
-    Node curr = root;
-    for (int i = 0; i < product.length(); i++) {
-      if (!curr.children.containsKey(product.charAt(i))) {
-        curr.children.put(product.charAt(i), new Node(product.charAt(i)));
-      }
-      curr = curr.children.get(product.charAt(i));
-      curr.possibleWords.add(product);
-      if (curr.possibleWords.size() > 3) {
-        curr.possibleWords.poll();
-      }
+  private class TrieNode {
+    TrieNode[] children;
+    PriorityQueue<String> matchingProducts;
+    
+    public TrieNode() {
+      this.children = new TrieNode[26];
+      this.matchingProducts = new PriorityQueue<>();
     }
   }
 }
-
-
-class Node {
-  char c;
-  Map<Character, Node> children;
-  PriorityQueue<String> possibleWords;
-  
-  public Node(char c) {
-    this.c = c;
-    children = new HashMap<>();
-    possibleWords = new PriorityQueue<>(Comparator.reverseOrder());
-  }
-}

From 512ec56b999c035cfb89a11a08655b1fe9b76b13 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 Jun 2022 07:57:59 -0700
Subject: [PATCH 1088/2175] Create Greatest English Letter in Upper and Lower
 Case.java

---
 ...nglish Letter in Upper and Lower Case.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Greatest English Letter in Upper and Lower Case.java

diff --git a/Easy/Greatest English Letter in Upper and Lower Case.java b/Easy/Greatest English Letter in Upper and Lower Case.java
new file mode 100644
index 00000000..2b7028ad
--- /dev/null
+++ b/Easy/Greatest English Letter in Upper and Lower Case.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public String greatestLetter(String s) {
+    boolean[] upperCasePresent = new boolean[26];
+    boolean[] lowerCasePresent = new boolean[26];
+    for (char c : s.toCharArray()) {
+      if (Character.isUpperCase(c)) {
+        upperCasePresent[c - 'A'] = true;
+      } else {
+        lowerCasePresent[c - 'a'] = true;
+      }
+    }
+    for (int i = 25; i >= 0; i--) {
+      if (upperCasePresent[i] && lowerCasePresent[i]) {
+        return String.valueOf((char) ('A' + i));
+      }
+    }
+    return "";
+  }
+}

From 3ab4d8f06e9b4c95a504ad76970b929aab7cd8f9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 20 Jun 2022 08:11:00 -0700
Subject: [PATCH 1089/2175] Create Short Encoding of Words.java

---
 Medium/Short Encoding of Words.java | 34 +++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Short Encoding of Words.java

diff --git a/Medium/Short Encoding of Words.java b/Medium/Short Encoding of Words.java
new file mode 100644
index 00000000..6eccb589
--- /dev/null
+++ b/Medium/Short Encoding of Words.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public int minimumLengthEncoding(String[] words) {
+    TrieNode root = new TrieNode();
+    Map<TrieNode, Integer> nodes = new HashMap<>();
+    for (int i = 0; i < words.length; i++) {
+      TrieNode curr = root;
+      for (int j = words[i].length() - 1; j >= 0; j--) {
+        if (curr.children[words[i].charAt(j) - 'a'] == null) {
+          curr.children[words[i].charAt(j) - 'a'] = new TrieNode();
+          curr.count++;
+        }
+        curr = curr.children[words[i].charAt(j) - 'a'];
+      }
+      nodes.put(curr, i);
+    }
+    int result = 0;
+    for (TrieNode node : nodes.keySet()) {
+      if (node.count == 0) {
+        result += words[nodes.get(node)].length() + 1;
+      }
+    }
+    return result;
+  }
+  
+  private class TrieNode {
+    TrieNode[] children;
+    int count;
+    
+    public TrieNode() {
+      this.children = new TrieNode[26];
+      this.count = 0;
+    }
+  }
+}

From 721d2db97984a92e4226c21da89588f9c594dee1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 20 Jun 2022 13:54:18 -0700
Subject: [PATCH 1090/2175] Update Multiply Strings.java

---
 Medium/Multiply Strings.java | 41 +++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 22 deletions(-)

diff --git a/Medium/Multiply Strings.java b/Medium/Multiply Strings.java
index fed474ad..7222ae47 100644
--- a/Medium/Multiply Strings.java	
+++ b/Medium/Multiply Strings.java	
@@ -1,33 +1,30 @@
 class Solution {
-    public String multiply(String num1, String num2) {
-    int[] result = new int[num1.length() + num2.length() + 1];
-    int idx = result.length - 1;
-    for (int i = num1.length() - 1; i >= 0; i--) {
-      int currIdx = idx;
+  public String multiply(String num1, String num2) {
+    int m = num1.length();
+    int n = num2.length();
+    int[] result = new int[m + n];
+    int endIdx = m + n - 1;
+    for (int i = m - 1; i >= 0; i--) {
+      int resultIdx = endIdx;
       int carry = 0;
-      for (int j = num2.length() - 1; j >= 0; j--) {
-        int currValue =
-            carry + Character.getNumericValue(num1.charAt(i)) * Character.getNumericValue(
-                num2.charAt(j)) + result[currIdx];
+      for (int j = n - 1; j >= 0; j--) {
+        int currValue = result[resultIdx] + carry + Character.getNumericValue(num1.charAt(i)) * Character.getNumericValue(num2.charAt(j));
         carry = currValue / 10;
-        currValue = currValue % 10;
-        result[currIdx--] = currValue;
+        result[resultIdx--] = currValue % 10;
       }
       while (carry > 0) {
-        int currValue = carry + result[currIdx];
-        carry = currValue / 10;
-        currValue = currValue % 10;
-        result[currIdx--] = currValue;
+        result[resultIdx--] = carry % 10;
+        carry /= 10;
       }
-      idx--;
+      endIdx--;
     }
-    StringBuilder sb = new StringBuilder();
-    int resultIdx = 0;
-    while (resultIdx < result.length && result[resultIdx] == 0) {
-      resultIdx++;
+    int idx = 0;
+    while (idx < result.length && result[idx] == 0) {
+      idx++;
     }
-    while (resultIdx < result.length) {
-      sb.append(result[resultIdx++]);
+    StringBuilder sb = new StringBuilder();
+    for (int i = idx; i < result.length; i++) {
+      sb.append(result[i]);
     }
     return sb.length() == 0 ? "0" : sb.toString();
   }

From 61c10eaaae1f63440498fb531f568f7400c45046 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 20 Jun 2022 16:39:59 -0700
Subject: [PATCH 1091/2175] Update Word Search.java

---
 Medium/Word Search.java | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/Medium/Word Search.java b/Medium/Word Search.java
index 6eb6993c..b5dc90c4 100644
--- a/Medium/Word Search.java	
+++ b/Medium/Word Search.java	
@@ -1,34 +1,34 @@
 class Solution {
-  public static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
   
   public boolean exist(char[][] board, String word) {
-    char[] letters = word.toCharArray();
+    int m = board.length;
+    int n = board[0].length;
     for (int i = 0; i < board.length; i++) {
       for (int j = 0; j < board[0].length; j++) {
-        if (dfs(board, 0, letters, i, j)) {
+        if (found(board, i, j, word, 0, m, n)) {
           return true;
         }
       }
     }
     return false;
   }
-
-  private boolean dfs(char[][] board, int idx, char[] letters, int i, int j) {
-    if (idx == letters.length) {
+  
+  private boolean found(char[][] board, int x, int y, String word, int idx, int m, int n) {
+    if (idx == word.length()) {
       return true;
     }
-    if (i < 0 || i >= board.length || j < 0 || j >= board[0].length) {
-      return false;
-    }
-    if (board[i][j] != letters[idx]) {
+    if (x < 0 || x == m || y < 0 || y == n || board[x][y] != word.charAt(idx)) {
       return false;
     }
-    board[i][j] ^= 256;
-    boolean exists = false;
+    board[x][y] = '#';
     for (int[] dir : DIRS) {
-      exists = exists || dfs(board, idx + 1, letters, i + dir[0], j + dir[1]);
+      if (found(board, x + dir[0], y + dir[1], word, idx + 1, m, n)) {
+        return true;
+      }
     }
-    board[i][j] ^= 256;
-    return exists;
+    board[x][y] = word.charAt(idx);
+    return false;
   }
 }

From acfe301c8ad6c582733047481b6ffcba5f8ece6f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 20 Jun 2022 17:27:44 -0700
Subject: [PATCH 1092/2175] Create Furthest Building You Can Reach.java

---
 Medium/Furthest Building You Can Reach.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Furthest Building You Can Reach.java

diff --git a/Medium/Furthest Building You Can Reach.java b/Medium/Furthest Building You Can Reach.java
new file mode 100644
index 00000000..2c901072
--- /dev/null
+++ b/Medium/Furthest Building You Can Reach.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int furthestBuilding(int[] heights, int bricks, int ladders) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    for (int i = 1; i < heights.length; i++) {
+      int diff = heights[i] - heights[i - 1];
+      if (diff > 0) {
+        pq.add(diff);
+        if (pq.size() > ladders) {
+          bricks -= pq.poll();
+        }
+        if (bricks < 0) {
+          return i - 1;
+        }
+      }
+    }
+    return heights.length - 1;
+  }
+}

From 869604b17775b4c4f3da44652eb948a0ac6a694f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 21 Jun 2022 14:33:24 -0700
Subject: [PATCH 1093/2175] Update Letter Combinations of a Phone Number.java

---
 ...Letter Combinations of a Phone Number.java | 44 +++++++------------
 1 file changed, 17 insertions(+), 27 deletions(-)

diff --git a/Medium/Letter Combinations of a Phone Number.java b/Medium/Letter Combinations of a Phone Number.java
index 81be5ec2..2c3a8c23 100644
--- a/Medium/Letter Combinations of a Phone Number.java	
+++ b/Medium/Letter Combinations of a Phone Number.java	
@@ -1,35 +1,25 @@
 class Solution {
+  
+  private final List<String> LETTER_MAPPING = Arrays.asList("abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz");
+  
   public List<String> letterCombinations(String digits) {
-    if (digits.length() == 0) {
-      return new ArrayList<>();
-    }
-    String[] strs = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
-    Map<Integer, String> map = new HashMap<>();
-    for (int i = 2; i <= 9; i++) {
-      map.put(i, strs[i - 2]);
-    }
-    List<String> list = new ArrayList<>();
-    helper(digits, 0, digits.length(), new StringBuilder(), map, list);
-    return list;
+    List<String> result = new ArrayList<>();
+    helper(digits, 0, new StringBuilder(), result);
+    return result;
   }
   
-  private void helper(
-    String digits, int idx, int n, StringBuilder sb, Map<Integer, String> map, List<String> list
-  ) {
-    if (idx == n) {
-      if (sb.length() == n) {
-        list.add(sb.toString());
-      }
-    }
-    else {
-      for (int i = idx; i < n; i++) {
-        int digit = Character.getNumericValue(digits.charAt(i));
-        for (char c : map.get(digit).toCharArray()) {
-          sb.append(c);
-          helper(digits, i + 1, n, sb, map, list);
-          sb.deleteCharAt(sb.length() - 1);
-        }
+  private void helper(String digits, int idx, StringBuilder sb, List<String> result) {
+    if (idx == digits.length()) {
+      if (sb.length() > 0) {
+        result.add(new String(sb.toString()));
       }
+      return;
+    } 
+    int mappingIdx = Character.getNumericValue(digits.charAt(idx)) - 2;
+    for (char c : LETTER_MAPPING.get(mappingIdx).toCharArray()) {
+      sb.append(c);
+      helper(digits, idx + 1, sb, result);
+      sb.deleteCharAt(sb.length() - 1);
     }
   }
 }

From b3308b6871230a329fa18a19a7592614129dbb62 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 21 Jun 2022 16:00:08 -0700
Subject: [PATCH 1094/2175] Update Insert Delete GetRandom O(1).java

---
 Medium/Insert Delete GetRandom O(1).java | 38 +++++++++++-------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/Medium/Insert Delete GetRandom O(1).java b/Medium/Insert Delete GetRandom O(1).java
index 1149d866..3b9b44ae 100644
--- a/Medium/Insert Delete GetRandom O(1).java	
+++ b/Medium/Insert Delete GetRandom O(1).java	
@@ -1,41 +1,39 @@
 class RandomizedSet {
 
-  /** Initialize your data structure here. */
-  Map<Integer, Integer> map;
-  List<Integer> list;
+  private List<Integer> randomizedSet;
+  private Map<Integer, Integer> indexMap;
+  private int currSize;
+  
   public RandomizedSet() {
-    map = new HashMap<>();
-    list = new ArrayList<>();
+    this.randomizedSet = new ArrayList<>();
+    this.indexMap = new HashMap<>();
+    this.currSize = 0;
   }
 
-  /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
   public boolean insert(int val) {
-    if (map.containsKey(val)) {
+    if (this.indexMap.containsKey(val)) {
       return false;
     }
-    list.add(val);
-    map.put(val, list.size() - 1);
+    this.randomizedSet.add(val);
+    this.indexMap.put(val, this.currSize++);
     return true;
   }
 
-  /** Removes a value from the set. Returns true if the set contained the specified element. */
   public boolean remove(int val) {
-    if (!map.containsKey(val)) {
+    if (!this.indexMap.containsKey(val)) {
       return false;
     }
-    int idx = map.get(val);
-    int lastIdx = list.size() - 1;
-    list.set(idx, list.get(lastIdx));
-    map.put(list.get(lastIdx), idx);
-    map.remove(val);
-    list.remove(lastIdx);
+    int valIdx = this.indexMap.get(val);
+    this.indexMap.put(this.randomizedSet.get(this.currSize - 1), valIdx);
+    this.randomizedSet.set(valIdx, this.randomizedSet.get(this.currSize - 1));
+    this.randomizedSet.remove(this.currSize - 1);
+    this.indexMap.remove(val);
+    this.currSize--;
     return true;
   }
 
-  /** Get a random element from the set. */
   public int getRandom() {
-    int idx = new Random().nextInt(list.size());
-    return list.get(idx);
+    return this.randomizedSet.get(new Random().nextInt(this.currSize));
   }
 }
 

From 7d7cdea03e27c99d545682c0959fc4b62cd44482 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 21 Jun 2022 20:35:15 -0700
Subject: [PATCH 1095/2175] Update Kth Largest Element in an Array.java

---
 Medium/Kth Largest Element in an Array.java | 28 ++++++++-------------
 1 file changed, 10 insertions(+), 18 deletions(-)

diff --git a/Medium/Kth Largest Element in an Array.java b/Medium/Kth Largest Element in an Array.java
index cc2f716c..c45d1f68 100644
--- a/Medium/Kth Largest Element in an Array.java	
+++ b/Medium/Kth Largest Element in an Array.java	
@@ -1,24 +1,16 @@
 class Solution {
   public int findKthLargest(int[] nums, int k) {
-    return quickSelect(nums, 0, nums.length - 1, nums.length - k);
-  }
-
-  private int quickSelect(int[] nums, int leftIdx, int rightIdx, int k) {
-    int pivot = nums[rightIdx];
-    int idx = leftIdx;
-    for (int i = leftIdx; i < rightIdx; i++) {
-      if (nums[i] <= pivot) {
-        swap(nums, i, idx);
-        idx++;
+    int[] counter = new int[20001];
+    for (int num : nums) {
+      counter[num + 10000]++;
+    }
+    for (int i = counter.length - 1; i >= 0; i--) {
+      if (counter[i] < k) {
+        k -= counter[i];
+      } else {
+        return i - 10000;
       }
     }
-    swap(nums, idx, rightIdx);
-    return idx == k ? nums[idx] : (idx > k ? quickSelect(nums, leftIdx, idx - 1, k) : quickSelect(nums, idx + 1, rightIdx, k));
-  }
-
-  private void swap(int[] nums, int idxOne, int idxTwo) {
-    int temp = nums[idxOne];
-    nums[idxOne] = nums[idxTwo];
-    nums[idxTwo] = temp;
+    return -1;
   }
 }

From f105faf04c7f4c4fdbf00c085f32acaf30936626 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 22 Jun 2022 08:28:29 -0700
Subject: [PATCH 1096/2175] Update Check If Two String Arrays are
 Equivalent.java

---
 ...k If Two String Arrays are Equivalent.java | 25 +++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/Easy/Check If Two String Arrays are Equivalent.java b/Easy/Check If Two String Arrays are Equivalent.java
index bbf06fcf..70a73e1a 100644
--- a/Easy/Check If Two String Arrays are Equivalent.java	
+++ b/Easy/Check If Two String Arrays are Equivalent.java	
@@ -1,6 +1,27 @@
 class Solution {
   public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
-    return Arrays.stream(word1).reduce((a, b) -> a + b)
-        .equals(Arrays.stream(word2).reduce((a, b) -> a + b));
+    int wordIdxOne = 0;
+    int wordIdxTwo = 0;
+    int idxOne = 0;
+    int idxTwo = 0;
+    while (wordIdxOne < word1.length && wordIdxTwo < word2.length) {
+      if (idxOne == word1[wordIdxOne].length() || idxTwo == word2[wordIdxTwo].length()) {
+        if (idxOne == word1[wordIdxOne].length()) {
+          wordIdxOne++;
+          idxOne = 0;
+        }
+        if (idxTwo == word2[wordIdxTwo].length()) {
+          wordIdxTwo++;
+          idxTwo = 0;
+        }
+      } else {
+        if (word1[wordIdxOne].charAt(idxOne) != word2[wordIdxTwo].charAt(idxTwo)) {
+          return false;
+        }
+        idxOne++;
+        idxTwo++;
+      }
+    }
+    return wordIdxOne == word1.length && wordIdxTwo == word2.length;
   }
 }

From 2d1bdd632b320ac40665accd3787808c94edcf50 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 23 Jun 2022 06:01:26 -0700
Subject: [PATCH 1097/2175] Create Course Schedule III.java

---
 Hard/Course Schedule III.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Hard/Course Schedule III.java

diff --git a/Hard/Course Schedule III.java b/Hard/Course Schedule III.java
new file mode 100644
index 00000000..ceea807c
--- /dev/null
+++ b/Hard/Course Schedule III.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int scheduleCourse(int[][] courses) {
+    Arrays.sort(courses, (a, b) -> a[1] - b[1]);
+    PriorityQueue<Integer> queue = new PriorityQueue<>((a, b) -> b - a);
+    int time = 0;
+    for (int[] course : courses) {
+      if (time + course[0] <= course[1]) {
+        queue.add(course[0]);
+        time += course[0];
+      } else if (!queue.isEmpty() && queue.peek() > course[0]) {
+        time += course[0] - queue.poll();
+        queue.add(course[0]);
+      }
+    }
+    return queue.size();
+  }
+}

From 7ff9c52341fd4cf535f4940ec7bf2cd567d9434d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 23 Jun 2022 09:28:44 -0700
Subject: [PATCH 1098/2175] Update Move Zeroes.java

---
 Easy/Move Zeroes.java | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/Easy/Move Zeroes.java b/Easy/Move Zeroes.java
index 0406592c..acd2e2cb 100644
--- a/Easy/Move Zeroes.java	
+++ b/Easy/Move Zeroes.java	
@@ -1,17 +1,15 @@
 class Solution {
   public void moveZeroes(int[] nums) {
-    int fast = 0;
-    int slow = 0;
-    int n = nums.length;
-    while (fast < n) {
-      if (nums[fast] != 0) {
-        nums[slow] = nums[fast];
-        slow++;
+    int startIdx = 0;
+    int endIdx = 0;
+    while (endIdx < nums.length) {
+      if (nums[endIdx] != 0) {
+        nums[startIdx++] = nums[endIdx];
       }
-      fast++;
+      endIdx++;
     }
-    while (slow < n) {
-      nums[slow++] = 0;
+    while (startIdx < nums.length) {
+      nums[startIdx++] = 0;
     }
   }
 }

From 928f2ec1d3cc0e2ad8ffae681907ee5147f508b8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 24 Jun 2022 08:34:42 -0700
Subject: [PATCH 1099/2175] Create Construct Target Array With Multiple
 Sums.java

---
 ...truct Target Array With Multiple Sums.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Hard/Construct Target Array With Multiple Sums.java

diff --git a/Hard/Construct Target Array With Multiple Sums.java b/Hard/Construct Target Array With Multiple Sums.java
new file mode 100644
index 00000000..a8a71438
--- /dev/null
+++ b/Hard/Construct Target Array With Multiple Sums.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public boolean isPossible(int[] target) {
+    if (target.length == 1) {
+      return target[0] == 1;
+    }
+    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+    int sum = 0;
+    for (int num : target) {
+      sum += num;
+      pq.add(num);
+    }
+    int n = target.length;
+    while (pq.peek() > 1) {
+      int largest = pq.poll();
+      int remaining = sum - largest;
+      if (remaining == 1) {
+        return true;
+      }
+      int delta = largest % remaining;
+      if (delta == 0 || delta == largest) {
+        return false;
+      }
+      pq.add(delta);
+      sum = sum - largest + delta;
+    }
+    return true;
+  }
+}

From 4b5cfe4792db4c48655a262999d79e4cc8db3839 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 24 Jun 2022 09:19:06 -0700
Subject: [PATCH 1100/2175] Create Sum of Numbers With Units Digit K.java

---
 Medium/Sum of Numbers With Units Digit K.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Sum of Numbers With Units Digit K.java

diff --git a/Medium/Sum of Numbers With Units Digit K.java b/Medium/Sum of Numbers With Units Digit K.java
new file mode 100644
index 00000000..024b9dbf
--- /dev/null
+++ b/Medium/Sum of Numbers With Units Digit K.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int minimumNumbers(int num, int k) {
+    if (num == 0) {
+      return 0;
+    }
+    for (int i = 1; i * k <= num && i <= 10; i++) {
+      if (k * i % 10 == num % 10) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}

From 9310448f007260511fb9681b7c764de4179de4d3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 24 Jun 2022 15:55:43 -0700
Subject: [PATCH 1101/2175] Update Slowest Key.java

---
 Easy/Slowest Key.java | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/Easy/Slowest Key.java b/Easy/Slowest Key.java
index 3e583542..e1c7f29f 100644
--- a/Easy/Slowest Key.java	
+++ b/Easy/Slowest Key.java	
@@ -1,18 +1,17 @@
 class Solution {
   public char slowestKey(int[] releaseTimes, String keysPressed) {
-    int startTime = 0;
-    int maxPressedTime = 0;
-    char keyWithLongestTime = keysPressed.charAt(0);
+    int maxReleaseTime = 0;
+    int maxReleaseTimeIdx = 0;
     for (int i = 0; i < releaseTimes.length; i++) {
-      int totalTime = releaseTimes[i] - startTime;
-      if (maxPressedTime < totalTime) {
-        keyWithLongestTime = keysPressed.charAt(i);
-        maxPressedTime = totalTime;
-      } else if (maxPressedTime == totalTime && keyWithLongestTime < keysPressed.charAt(i)) {
-        keyWithLongestTime = keysPressed.charAt(i);
+      int idx = keysPressed.charAt(i) - 'a';
+      int currReleaseTime = i == 0 ? releaseTimes[i] : (releaseTimes[i] - releaseTimes[i - 1]);
+      if (currReleaseTime > maxReleaseTime) {
+        maxReleaseTimeIdx = idx;
+        maxReleaseTime = currReleaseTime;
+      } else if (maxReleaseTime == currReleaseTime && maxReleaseTimeIdx < idx) {
+        maxReleaseTimeIdx = idx;
       }
-      startTime = releaseTimes[i];
     }
-    return keyWithLongestTime;
-  }
+    return ((char) ('a' + maxReleaseTimeIdx));
+  }   
 }

From 0579f408de00d485c2fddc9e03f51d8a361ad09b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 25 Jun 2022 08:10:28 -0700
Subject: [PATCH 1102/2175] Update and rename Easy/Non-decreasing Array.java to
 Medium/Non-decreasing Array.java

---
 Easy/Non-decreasing Array.java   | 20 --------------------
 Medium/Non-decreasing Array.java | 19 +++++++++++++++++++
 2 files changed, 19 insertions(+), 20 deletions(-)
 delete mode 100644 Easy/Non-decreasing Array.java
 create mode 100644 Medium/Non-decreasing Array.java

diff --git a/Easy/Non-decreasing Array.java b/Easy/Non-decreasing Array.java
deleted file mode 100644
index e6ce5b01..00000000
--- a/Easy/Non-decreasing Array.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-  public boolean checkPossibility(int[] nums) {
-    Integer probIdx = null;
-    for (int i = 0; i < nums.length - 1; i++) {
-      if (nums[i] > nums[i + 1]) {
-        if (probIdx != null) {
-          return false;
-        }
-        probIdx = i;
-      }
-    }
-    return (
-      probIdx == null || 
-      probIdx == 0 || 
-      probIdx == (nums.length - 2) || 
-      nums[probIdx - 1] <= nums[probIdx + 1] ||
-      nums[probIdx] <= nums[probIdx + 2]
-    );
-  }
-}
diff --git a/Medium/Non-decreasing Array.java b/Medium/Non-decreasing Array.java
new file mode 100644
index 00000000..489db551
--- /dev/null
+++ b/Medium/Non-decreasing Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public boolean checkPossibility(int[] nums) {
+    boolean mismatch = false;
+    for (int i = 1; i < nums.length; i++) {
+      if (nums[i - 1] > nums[i]) {
+        if (mismatch) {
+          return false;
+        }
+        if (i < 2 || nums[i - 2] <= nums[i]) {
+          nums[i - 1] = nums[i];
+        } else {
+          nums[i] = nums[i - 1];
+        }
+        mismatch = true;
+      }
+    }
+    return true;
+  }
+}

From 7f1f1bdfae78a008b2fd6e9f442b204a8a059fe2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 25 Jun 2022 10:50:37 -0700
Subject: [PATCH 1103/2175] Create Count Asterisks.java

---
 Easy/Count Asterisks.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Count Asterisks.java

diff --git a/Easy/Count Asterisks.java b/Easy/Count Asterisks.java
new file mode 100644
index 00000000..14a53656
--- /dev/null
+++ b/Easy/Count Asterisks.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int countAsterisks(String s) {
+    int asteriskCount = 0;
+    int barCount = 0;
+    for (char c : s.toCharArray()) {
+      if (c == '|') {
+        barCount++;
+      } else if (c == '*') {
+        if (barCount % 2 == 0) {
+          asteriskCount++;
+        }
+      }
+    }
+    return asteriskCount;
+  }
+}

From cbf463368fb880e28db3b2dc1a8b3878a0ec49bb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 25 Jun 2022 13:58:44 -0700
Subject: [PATCH 1104/2175] Create Count Unreachable Pairs of Nodes in an
 Undirected Graph.java

---
 ...Pairs of Nodes in an Undirected Graph.java | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java

diff --git a/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java b/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java
new file mode 100644
index 00000000..b8f9bb09
--- /dev/null
+++ b/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public long countPairs(int n, int[][] edges) {
+    Map<Integer, List<Integer>> graph = new HashMap<>();
+    for (int[] edge : edges) {
+      graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    }
+    long unreachableNodes = (((long) n) * (n - 1)) / 2;
+    boolean[] visited = new boolean[n];
+    for (int i = 0; i < n; i++) {
+      if (!visited[i]) {
+        long[] reachCount = {0};
+        dfs(graph, i, reachCount, visited);
+        unreachableNodes -= (reachCount[0] * (reachCount[0] - 1)) / 2;
+      }      
+    }
+    return unreachableNodes;
+  }
+  
+  private void dfs(Map<Integer, List<Integer>> graph, int node, long[] reachCount, boolean[] visited) {
+    visited[node] = true;
+    reachCount[0]++;
+    for (Integer conn : graph.getOrDefault(node, new ArrayList<>())) {
+      if (!visited[conn]) {
+        dfs(graph, conn, reachCount, visited);
+      }
+    }
+  }
+}

From fd70090594917916d177d34f611823a823a1e6d6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Jun 2022 14:08:14 -0700
Subject: [PATCH 1105/2175] Create Maximum Points You Can Obtain from
 Cards.java

---
 ...aximum Points You Can Obtain from Cards.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Maximum Points You Can Obtain from Cards.java

diff --git a/Medium/Maximum Points You Can Obtain from Cards.java b/Medium/Maximum Points You Can Obtain from Cards.java
new file mode 100644
index 00000000..b9648446
--- /dev/null
+++ b/Medium/Maximum Points You Can Obtain from Cards.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int maxScore(int[] cardPoints, int k) {
+    int n = cardPoints.length;
+    int[] prefixSum = new int[k + 1];
+    int[] suffixSum = new int[k + 1];
+    for (int i = 0; i < k; i++) {
+      prefixSum[i + 1] = cardPoints[i] + prefixSum[i];
+      suffixSum[i + 1] = cardPoints[n - i - 1] + suffixSum[i];
+    }
+    int result = 0;
+    for (int i = 0; i <= k; i++) {
+      int currScore = prefixSum[i] + suffixSum[k - i];
+      result = Math.max(result, currScore);
+    }
+    return result;
+  }
+}

From dab0bccbc3bc49bdd002195455f7d5f5fd97bb17 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Jun 2022 14:13:17 -0700
Subject: [PATCH 1106/2175] Create Check if Matrix Is X-Matrix.java

---
 Easy/Check if Matrix Is X-Matrix.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Check if Matrix Is X-Matrix.java

diff --git a/Easy/Check if Matrix Is X-Matrix.java b/Easy/Check if Matrix Is X-Matrix.java
new file mode 100644
index 00000000..34bc31af
--- /dev/null
+++ b/Easy/Check if Matrix Is X-Matrix.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public boolean checkXMatrix(int[][] grid) {
+    int n = grid.length;
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        if (i == j || i + j == n - 1) {
+          if (grid[i][j] == 0) {
+            return false;
+          }
+        } else {
+          if (grid[i][j] != 0) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+}

From ed39e959d3cefbd0507f36fbe88c3f28f101fb9d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Jun 2022 18:56:20 -0700
Subject: [PATCH 1107/2175] Update Partitioning Into Minimum Number Of
 Deci-Binary Numbers.java

---
 ...ing Into Minimum Number Of Deci-Binary Numbers.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Medium/Partitioning Into Minimum Number Of Deci-Binary Numbers.java b/Medium/Partitioning Into Minimum Number Of Deci-Binary Numbers.java
index 4ede9af8..4bd5953a 100644
--- a/Medium/Partitioning Into Minimum Number Of Deci-Binary Numbers.java	
+++ b/Medium/Partitioning Into Minimum Number Of Deci-Binary Numbers.java	
@@ -1,9 +1,9 @@
 class Solution {
   public int minPartitions(String n) {
-    return n.chars()
-            .mapToObj(c -> (char) c)
-            .mapToInt(Character::getNumericValue)
-            .reduce(Integer::max)
-            .orElse(0);
+    int maxDigit = Character.getNumericValue(n.charAt(0));
+    for (char c : n.toCharArray()) {
+      maxDigit = Math.max(maxDigit, Character.getNumericValue(c));
+    }
+    return maxDigit;
   }
 }

From b06bce438d3fb731d91ff9855ec555d43fc2a11b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 27 Jun 2022 17:14:40 -0700
Subject: [PATCH 1108/2175] Update Design Parking System.java

---
 Easy/Design Parking System.java | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/Easy/Design Parking System.java b/Easy/Design Parking System.java
index 6aa29a71..331e14fc 100644
--- a/Easy/Design Parking System.java	
+++ b/Easy/Design Parking System.java	
@@ -1,15 +1,12 @@
 class ParkingSystem {
-  int[] slots;
+  
+  private int[] availableSpaces;
   public ParkingSystem(int big, int medium, int small) {
-    slots = new int[]{big, medium, small};
+    this.availableSpaces = new int[]{big, medium, small};
   }
 
   public boolean addCar(int carType) {
-    if (slots[carType - 1] == 0) {
-      return false;
-    }
-    slots[carType - 1]--;
-    return true;
+    return this.availableSpaces[carType - 1]-- > 0;
   }
 }
 

From e2fd43957f4260c19c1185251ba55aecac143b41 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 28 Jun 2022 09:59:54 -0700
Subject: [PATCH 1109/2175] Create Design an Expression Tree With Evaluate
 Function.java

---
 ...xpression Tree With Evaluate Function.java | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 Medium/Design an Expression Tree With Evaluate Function.java

diff --git a/Medium/Design an Expression Tree With Evaluate Function.java b/Medium/Design an Expression Tree With Evaluate Function.java
new file mode 100644
index 00000000..123e21df
--- /dev/null
+++ b/Medium/Design an Expression Tree With Evaluate Function.java	
@@ -0,0 +1,79 @@
+/**
+ * This is the interface for the expression tree Node.
+ * You should not remove it, and you can define some classes to implement it.
+ */
+
+abstract class Node {
+  public abstract int evaluate();
+  // define your fields here
+};
+
+class NumericNode extends Node {
+  
+  private int val;
+  
+  public NumericNode(int val) {
+    this.val = val;  
+  }
+  
+  public int evaluate() {
+    return this.val;
+  }
+}
+
+class OperatorNode extends Node {
+  private char operator;
+  private Node leftNode;
+  private Node rightNode;
+  
+  public OperatorNode(char operator, Node leftNode, Node rightNode) {
+    this.operator = operator;
+    this.leftNode = leftNode;
+    this.rightNode = rightNode;
+  }
+  
+  public int evaluate() {
+    int leftValue = this.leftNode == null ? 0 : this.leftNode.evaluate();
+    int rightValue = this.rightNode == null ? 0 : this.rightNode.evaluate();
+    if (this.operator == '+') {
+      return leftValue + rightValue;
+    } else if (this.operator == '-') {
+      return leftValue - rightValue;
+    } else if (this.operator == '*') {
+      return leftValue * rightValue;
+    } else {
+      return leftValue / rightValue;
+    }
+  }
+}
+
+
+/**
+ * This is the TreeBuilder class.
+ * You can treat it as the driver code that takes the postinfix input 
+ * and returns the expression tree represnting it as a Node.
+ */
+
+class TreeBuilder {
+  Node buildTree(String[] postfix) {
+    Stack<Node> stack = new Stack<>();
+    for(String token: postfix){
+      if (token.equals("*") || token.equals("+") || token.equals("-") || token.equals("/")) {
+        Node o2 = stack.pop();
+        Node o1 = stack.pop();
+        stack.push(new OperatorNode(token.charAt(0), o1, o2));
+      } else{
+        stack.push(new NumericNode(Integer.parseInt(token)));
+      }
+    }
+    return stack.pop();
+  }
+};
+
+
+/**
+ * Your TreeBuilder object will be instantiated and called as such:
+ * TreeBuilder obj = new TreeBuilder();
+ * Node expTree = obj.buildTree(postfix);
+ * int ans = expTree.evaluate();
+ */

From d75843b146d7ba714cb65117de2daddab5682897 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 28 Jun 2022 12:57:03 -0700
Subject: [PATCH 1110/2175] Update Word Search II.java

---
 Hard/Word Search II.java | 92 ++++++++++++++++++++--------------------
 1 file changed, 45 insertions(+), 47 deletions(-)

diff --git a/Hard/Word Search II.java b/Hard/Word Search II.java
index 729cf044..3e9ce51a 100644
--- a/Hard/Word Search II.java	
+++ b/Hard/Word Search II.java	
@@ -1,62 +1,60 @@
 class Solution {
-  public List<String> findWords(char[][] board, String[] words) {
-    List<String> result = new ArrayList<>();
-    TrieNode root = buildTrie(words);
-    for (int i = 0; i < board.length; i++) {
-      for (int j = 0; j < board[0].length; j++) {
-        dfs(board, i, j, result, root);
-      }
-    }
-    return result;
-  }
   
-  private TrieNode buildTrie(String[] words) {
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
+  
+  public List<String> findWords(char[][] board, String[] words) {
     TrieNode root = new TrieNode();
     for (String word : words) {
-      TrieNode temp = root;
-      for (char c : word.toCharArray()) {
-        if (temp.children[c - 'a'] == null) {
-          temp.children[c - 'a'] = new TrieNode();
+      TrieNode node = root;
+      for (Character letter : word.toCharArray()) {
+        if (node.children.containsKey(letter)) {
+          node = node.children.get(letter);
+        } else {
+          TrieNode newNode = new TrieNode();
+          node.children.put(letter, newNode);
+          node = newNode;
         }
-        temp = temp.children[c - 'a'];
-     }
-       temp.word = word;
-    }
-    return root;
-  }
-
-  private void dfs(char[][] board, int i, int j, List<String> result, TrieNode root) {
-    char c = board[i][j];
-    if (c == '#' || root.children[c - 'a'] == null) {
-      return;
+      }
+      node.word = word;
     }
-    root = root.children[c - 'a'];
-    if (root.word != null) {
-      result.add(root.word);
-      root.word = null;
+    List<String> result = new ArrayList<>();
+    for (int row = 0; row < board.length; ++row) {
+      for (int col = 0; col < board[row].length; ++col) {
+        if (root.children.containsKey(board[row][col])) {
+          backtracking(row, col, root, result, board);
+        }
+      }
     }
-    board[i][j] = '#';
-    triggerDfsIfValid(board, i, j, result, root);
-    board[i][j] = c;
+    return result;
   }
   
-  private void triggerDfsIfValid(char[][] board, int i, int j, List<String> result, TrieNode root) {
-    if (i > 0) {
-      dfs(board, i - 1, j, result, root);
-    }
-    if (j > 0) {
-      dfs(board, i, j - 1, result, root);
-    }
-    if (i < board.length - 1) {
-      dfs(board, i + 1, j, result, root);
+  private void backtracking(int row, int col, TrieNode parent, List<String> result, char[][] board) {
+    char letter = board[row][col];
+    TrieNode currNode = parent.children.get(letter);
+    if (currNode.word != null) {
+      result.add(currNode.word);
+      currNode.word = null;
+    }
+    board[row][col] = '#';
+    for (int[] dir : DIRS) {
+      int newRow = row + dir[0];
+      int newCol = col + dir[1];
+      if (newRow < 0 || newRow >= board.length || newCol < 0 || newCol >= board[0].length) {
+        continue;
+      }
+      if (currNode.children.containsKey(board[newRow][newCol])) {
+        backtracking(newRow, newCol, currNode, result, board);
+      }
     }
-    if (j < board[0].length - 1) {
-      dfs(board, i, j + 1, result, root);
+    board[row][col] = letter;
+    if (currNode.children.isEmpty()) {
+      parent.children.remove(letter);
     }
   }
   
-  class TrieNode {
-    TrieNode[] children = new TrieNode[26];
-    String word;
+  private class TrieNode {
+    Map<Character, TrieNode> children = new HashMap<Character, TrieNode>();
+    String word = null;
+    public TrieNode() {}
   }
 }

From f62249b0ed2655e81f69269767d6484a7ee02467 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 28 Jun 2022 14:16:48 -0700
Subject: [PATCH 1111/2175] Create Bomb Enemy.java

---
 Medium/Bomb Enemy.java | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Bomb Enemy.java

diff --git a/Medium/Bomb Enemy.java b/Medium/Bomb Enemy.java
new file mode 100644
index 00000000..c6259b7a
--- /dev/null
+++ b/Medium/Bomb Enemy.java	
@@ -0,0 +1,42 @@
+class Solution {
+  public int maxKilledEnemies(char[][] grid) {
+    if (grid.length == 0) {
+      return 0;
+    }
+    int rows = grid.length;
+    int cols = grid[0].length;
+    int maxCount = 0;
+    int rowHits = 0;
+    int[] colHits = new int[cols];
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (j == 0 || grid[i][j - 1] == 'W') {
+          rowHits = 0;
+          for (int k = j; k < cols; k++) {
+            if (grid[i][k] == 'W') {
+              break;
+            }
+            if (grid[i][k] == 'E') {
+              rowHits++;
+            }
+          }
+        }
+        if (i == 0 || grid[i - 1][j] == 'W') {
+          colHits[j] = 0;
+          for (int k = i; k < rows; k++) {
+            if (grid[k][j] == 'W') {
+              break;
+            }
+            if (grid[k][j] == 'E') {
+              colHits[j]++;
+            }
+          }
+        }
+        if (grid[i][j] == '0') {
+          maxCount = Math.max(maxCount, rowHits + colHits[j]);
+        }
+      }
+    }
+    return maxCount;
+  }
+}

From 70ca4faabcf03853b7435ac762a2fdb693df9146 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 28 Jun 2022 14:51:09 -0700
Subject: [PATCH 1112/2175] Update Design Twitter.java

---
 Medium/Design Twitter.java | 126 +++++++++++++------------------------
 1 file changed, 45 insertions(+), 81 deletions(-)

diff --git a/Medium/Design Twitter.java b/Medium/Design Twitter.java
index cd5361e2..8009a1d6 100644
--- a/Medium/Design Twitter.java	
+++ b/Medium/Design Twitter.java	
@@ -1,105 +1,69 @@
-class Twitter {
+import java.util.Map.Entry;
+
 
-  /** Initialize your data structure here. */
-  Map<Integer, User> userMap;
+class Twitter {
 
-  int tweetTimeStamp;
+  private final Map<Integer, Set<Integer>> userFollowing;
+  private final Map<Integer, TweetNode> userToTweet;
+  private int timestamp;
 
   public Twitter() {
-    userMap = new HashMap<>();
-    tweetTimeStamp = 0;
+    this.userFollowing = new HashMap<>();
+    this.timestamp = 0;
+    this.userToTweet = new HashMap<>();
   }
 
-  /** Compose a new tweet. */
   public void postTweet(int userId, int tweetId) {
-    createUserIfNotExist(userId);
-    userMap.get(userId).addTweet(tweetId, tweetTimeStamp++);
+    TweetNode tweetNode = new TweetNode(tweetId, this.timestamp++);
+    if (this.userToTweet.containsKey(userId)) {
+      tweetNode.next = this.userToTweet.get(userId);
+    }
+    this.userToTweet.put(userId, tweetNode);
   }
 
-  /**
-   * Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must
-   * be posted by users who the user followed or by the user herself. Tweets must be ordered from
-   * most recent to least recent.
-   */
   public List<Integer> getNewsFeed(int userId) {
-    createUserIfNotExist(userId);
-    List<User> usersFollowed =
-        userMap.get(userId).following.stream()
-            .map(e -> userMap.get(e))
-            .collect(Collectors.toList());
-    return userMap.get(userId).getFeed(usersFollowed);
+    PriorityQueue<TweetNode> priorityQueue =
+        new PriorityQueue<>((o1, o2) -> o2.timestamp - o1.timestamp);
+    priorityQueue.addAll(
+        this.userToTweet.entrySet().stream()
+            .filter(
+                entry ->
+                    entry.getKey() == userId
+                        || this.userFollowing
+                            .getOrDefault(userId, new HashSet<>())
+                            .contains(entry.getKey()))
+            .map(Entry::getValue)
+            .collect(Collectors.toList()));
+    List<Integer> result = new ArrayList<>();
+    while (!priorityQueue.isEmpty() && result.size() < 10) {
+      TweetNode removed = priorityQueue.remove();
+      result.add(removed.tweetId);
+      if (removed.next != null) {
+        priorityQueue.add(removed.next);
+      }
+    }
+    return result;
   }
 
-  /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
   public void follow(int followerId, int followeeId) {
-    if (followerId != followeeId) {
-      createUserIfNotExist(followerId);
-      createUserIfNotExist(followeeId);
-      userMap.get(followerId).following.add(followeeId);
-    }
+    this.userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).add(followeeId);
   }
 
-  /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
   public void unfollow(int followerId, int followeeId) {
-    if (followerId != followeeId) {
-      createUserIfNotExist(followerId);
-      createUserIfNotExist(followeeId);
-      userMap.get(followerId).following.remove(followeeId);
+    if (this.userFollowing.getOrDefault(followerId, new HashSet<>()).contains(followeeId)) {
+      this.userFollowing.get(followerId).remove(followeeId);
     }
   }
 
-  private void createUserIfNotExist(int userId) {
-    userMap.computeIfAbsent(userId, k -> new User(userId));
-  }
-}
-
-class User {
-  int id;
-  Set<Integer> following;
-  PriorityQueue<Tweet> tweets;
+  private static class TweetNode {
+    int tweetId;
+    int timestamp;
+    TweetNode next;
 
-  public User(int id) {
-    this.id = id;
-    following = new HashSet<>();
-    tweets = new PriorityQueue<>((t1, t2) -> t2.timestamp - t1.timestamp);
-  }
-
-  public void addTweet(int tweetId, int timestamp) {
-    tweets.add(new Tweet(tweetId, timestamp));
-  }
-
-  public List<Integer> getFeed(List<User> usersFollowed) {
-    PriorityQueue<PriorityQueue<Tweet>> allTweets =
-        new PriorityQueue<>(
-            (t1, t2) -> {
-              if (t2.peek() != null) {
-                return t2.peek().timestamp - (t1.peek() != null ? t1.peek().timestamp : 0);
-              }
-              return 0;
-            });
-    usersFollowed.add(this);
-    usersFollowed.stream()
-        .filter(user -> !user.tweets.isEmpty())
-        .forEach(user -> allTweets.add(new PriorityQueue<>(user.tweets)));
-    List<Integer> feed = new ArrayList<>();
-    while (feed.size() < 10 && !allTweets.isEmpty()) {
-      PriorityQueue<Tweet> removed = allTweets.remove();
-      feed.add(removed.poll().id);
-      if (!removed.isEmpty()) {
-        allTweets.add(removed);
-      }
+    public TweetNode(int tweetId, int timestamp) {
+      this.tweetId = tweetId;
+      this.timestamp = timestamp;
     }
-    return feed;
-  }
-}
-
-class Tweet {
-  int id;
-  int timestamp;
-
-  public Tweet(int id, int timestamp) {
-    this.id = id;
-    this.timestamp = timestamp;
   }
 }
 

From 6d45f98925805f2440fc937acbc59628fc126327 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 29 Jun 2022 07:41:59 -0700
Subject: [PATCH 1113/2175] Create Put Boxes Into the Warehouse I.java

---
 Medium/Put Boxes Into the Warehouse I.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Put Boxes Into the Warehouse I.java

diff --git a/Medium/Put Boxes Into the Warehouse I.java b/Medium/Put Boxes Into the Warehouse I.java
new file mode 100644
index 00000000..3d8b4a59
--- /dev/null
+++ b/Medium/Put Boxes Into the Warehouse I.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int maxBoxesInWarehouse(int[] boxes, int[] warehouse) {
+    Arrays.sort(boxes);
+    for (int i = 1; i < warehouse.length; i++) {
+      warehouse[i] = Math.min(warehouse[i - 1], warehouse[i]);
+    }
+    int count = 0;
+    for (int i = warehouse.length - 1; i >= 0; i--) {
+      if (count < boxes.length && boxes[count] <= warehouse[i]) {
+        count++;
+      }
+    }
+    return count;
+  }
+}

From f92d1d65c3f928f54e71cd8b2a782c42c2d422a6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 29 Jun 2022 08:14:22 -0700
Subject: [PATCH 1114/2175] Update Queue Reconstruction By Height.java

---
 Medium/Queue Reconstruction By Height.java | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/Medium/Queue Reconstruction By Height.java b/Medium/Queue Reconstruction By Height.java
index 5314da67..4f422303 100644
--- a/Medium/Queue Reconstruction By Height.java	
+++ b/Medium/Queue Reconstruction By Height.java	
@@ -1,20 +1,11 @@
 class Solution {
   public int[][] reconstructQueue(int[][] people) {
-    Arrays.sort(people, new Comparator<int[]>(){
-      public int compare(int[] o1, int[] o2) {
-        int c = o2[0] - o1[0];
-        if (c != 0) {
-          return c;
-        }
-        return o1[1] - o2[1]; 
-      }
-    });
-    System.out.println();
-    List<int[]> list = new ArrayList<>();
+    Arrays.sort(people, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]);
+    List<int[]> result = new ArrayList<>();
     for (int[] p : people) {
-      list.add(p[1], p);
+      result.add(p[1], p);
     }
     int n = people.length;
-    return list.toArray(new int[n][2]);
+    return result.toArray(new int[n][2]);
   }
 }

From 46a8666c3cd4655a265906c3c9e64b059d6ac3a9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 30 Jun 2022 07:06:14 -0700
Subject: [PATCH 1115/2175] Create Minimum Moves to Equal Array Elements.java

---
 Medium/Minimum Moves to Equal Array Elements.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Minimum Moves to Equal Array Elements.java

diff --git a/Medium/Minimum Moves to Equal Array Elements.java b/Medium/Minimum Moves to Equal Array Elements.java
new file mode 100644
index 00000000..78d30c6f
--- /dev/null
+++ b/Medium/Minimum Moves to Equal Array Elements.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int minMoves(int[] nums) {
+    Arrays.sort(nums);
+    int moves = 0;
+    for (int i = 1; i < nums.length; i++) {
+      int diff = (moves + nums[i]) - nums[i - 1];
+      nums[i] += moves;
+      moves += diff;
+    }
+    return moves;
+  }
+}

From 1b560a3717110e10063de006448f86203e170463 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 30 Jun 2022 07:08:01 -0700
Subject: [PATCH 1116/2175] Update Minimum Moves to Equal Array Elements
 II.java

---
 ...imum Moves to Equal Array Elements II.java | 23 ++++++++-----------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Medium/Minimum Moves to Equal Array Elements II.java b/Medium/Minimum Moves to Equal Array Elements II.java
index 921078ed..1a0ac919 100644
--- a/Medium/Minimum Moves to Equal Array Elements II.java	
+++ b/Medium/Minimum Moves to Equal Array Elements II.java	
@@ -1,17 +1,12 @@
 class Solution {
-    public int minMoves2(int[] nums) {
-        int i = 0;
-        int j = nums.length-1;
-        int c = 0;
-        
-        Arrays.sort(nums);
-        
-        while (i < j) {
-            c += nums[j] - nums[i];
-            i++;
-            j--;
-        }
-        
-        return c;
+  public int minMoves2(int[] nums) {
+    Arrays.sort(nums);
+    int sum = 0;
+    int start = 0;
+    int end = nums.length - 1;
+    while (start < end) {
+      sum += nums[end--] - nums[start++];
     }
+    return sum;
+  }
 }

From 88e9cd40544458a99a26e873e67292ce3392f924 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 30 Jun 2022 07:52:14 -0700
Subject: [PATCH 1117/2175] Update Implement Trie (Prefix Tree).java

---
 Medium/Implement Trie (Prefix Tree).java | 60 +++++++++++-------------
 1 file changed, 28 insertions(+), 32 deletions(-)

diff --git a/Medium/Implement Trie (Prefix Tree).java b/Medium/Implement Trie (Prefix Tree).java
index f5aaa30e..8df3049a 100644
--- a/Medium/Implement Trie (Prefix Tree).java	
+++ b/Medium/Implement Trie (Prefix Tree).java	
@@ -1,60 +1,56 @@
 class Trie {
-
-  TrieNode root;
+  
+  private TrieNode root;
+  
   public Trie() {
-    root = new TrieNode('-');
+    this.root = new TrieNode();
   }
 
   public void insert(String word) {
-    TrieNode node = root;
-    for (int i = 0; i < word.length(); i++) {
-      if (node.children[word.charAt(i) - 'a'] == null) {
-        node.children[word.charAt(i) - 'a'] = new TrieNode(word.charAt(i));
-      }
-      node = node.children[word.charAt(i) - 'a'];
-      if (i == word.length() - 1) {
-        node.isWord = true;
+    TrieNode curr = root;
+    for (char c : word.toCharArray()) {
+      if (!curr.children.containsKey(c)) {
+        curr.children.put(c, new TrieNode());
       }
+      curr = curr.children.get(c);
     }
+    curr.isWord = true;
   }
 
   public boolean search(String word) {
-    TrieNode node = searchHelper(word);
-    return node != null && node.isWord;
+    TrieNode searchNode = searchHelper(word);
+    return searchNode != null && searchNode.isWord;
   }
 
   public boolean startsWith(String prefix) {
     return searchHelper(prefix) != null;
   }
   
-  private TrieNode searchHelper(String word) {
-    TrieNode node = root;
-    for (int i = 0; i < word.length(); i++) {
-      if (node.children[word.charAt(i) - 'a'] == null) {
+  private TrieNode searchHelper(String s) {
+    TrieNode curr = root;
+    for (char c : s.toCharArray()) {
+      if (!curr.children.containsKey(c)) {
         return null;
       }
-      node = node.children[word.charAt(i) - 'a'];
+      curr = curr.children.get(c);
     }
-    return node;
+    return curr;
   }
   
-  class TrieNode {
-    TrieNode[] children;
+  private class TrieNode {
+    Map<Character, TrieNode> children;
     boolean isWord;
-    char c;
     
-    public TrieNode(char c) {
-      this.c = c;
-      children = new TrieNode[26];
-      isWord = false;
+    public TrieNode() {
+      this.children = new HashMap<>();
     }
   }
 }
 
 /**
- * Your Trie object will be instantiated and called as such:
- * Trie obj = new Trie();
- * obj.insert(word);
- * boolean param_2 = obj.search(word);
- * boolean param_3 = obj.startsWith(prefix);
- */
+* Your Trie object will be instantiated and called as such:
+* Trie obj = new Trie();
+* obj.insert(word);
+* boolean param_2 = obj.search(word);
+* boolean param_3 = obj.startsWith(prefix);
+*/

From ae12464c9a458e95939b1273527a2313a66fbc78 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 30 Jun 2022 07:56:33 -0700
Subject: [PATCH 1118/2175] Update Permutations.java

---
 Medium/Permutations.java | 35 ++++++++++++++++-------------------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/Medium/Permutations.java b/Medium/Permutations.java
index f09beb5e..760b7452 100644
--- a/Medium/Permutations.java
+++ b/Medium/Permutations.java
@@ -1,25 +1,22 @@
 class Solution {
   public List<List<Integer>> permute(int[] nums) {
-    List<List<Integer>> ans = new ArrayList <>();
-    Set<Integer> used = new HashSet <>();
-    permuteHelper(nums, nums.length, ans, used, new ArrayList<>());
-    return ans;
+    List<List<Integer>> result = new ArrayList<>();
+    helper(nums, result, new ArrayList<>(), new boolean[nums.length]);
+    return result;
   }
-
-  private void permuteHelper(int[] nums, int length, List<List<Integer>> ans,
-                                    Set<Integer> used, ArrayList<Integer> curr) {
-    if (curr.size() == length) {
-      ans.add(new ArrayList <>(curr));
-      return;
-    }
-
-    for (int i = 0; i < length; i++) {
-      if (!used.contains(nums[i])) {
-        used.add(nums[i]);
-        curr.add(nums[i]);
-        permuteHelper(nums, length, ans, used, curr);
-        used.remove(nums[i]);
-        curr.remove(curr.size() - 1);
+  
+  private void helper(int[] nums, List<List<Integer>> result, List<Integer> curr, boolean[] visited) {
+    if (curr.size() == nums.length) {
+      result.add(new ArrayList<>(curr));
+    } else {
+      for (int i = 0; i < nums.length; i++) {
+        if (!visited[i]) {
+          visited[i] = true;
+          curr.add(nums[i]);
+          helper(nums, result, curr, visited);
+          visited[i] = false;
+          curr.remove(curr.size() - 1);
+        }
       }
     }
   }

From 1a2857159c24727a8ac128e8a9cfe1ec42785012 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 30 Jun 2022 14:44:14 -0700
Subject: [PATCH 1119/2175] Update Sort Integers by The Number of 1 Bits.java

---
 Easy/Sort Integers by The Number of 1 Bits.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Easy/Sort Integers by The Number of 1 Bits.java b/Easy/Sort Integers by The Number of 1 Bits.java
index d2fc14c3..4b1e7c2c 100644
--- a/Easy/Sort Integers by The Number of 1 Bits.java	
+++ b/Easy/Sort Integers by The Number of 1 Bits.java	
@@ -1,9 +1,8 @@
 class Solution {
   public int[] sortByBits(int[] arr) {
-    return Arrays.stream(arr).boxed()
+    return Arrays.stream(arr)
+        .boxed()
         .sorted(Comparator.comparingInt(Integer::bitCount).thenComparingInt(o -> o))
-        .collect(Collectors.toList())
-        .stream()
         .mapToInt(Integer::intValue)
         .toArray();
   }

From e31c6a6ac1e055c1a376ded2218b31b2bd91c18a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 1 Jul 2022 08:00:06 -0700
Subject: [PATCH 1120/2175] Update Length of last word.java

---
 Easy/Length of last word.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Easy/Length of last word.java b/Easy/Length of last word.java
index 8768e506..a351538e 100644
--- a/Easy/Length of last word.java	
+++ b/Easy/Length of last word.java	
@@ -1,14 +1,13 @@
 class Solution {
   public int lengthOfLastWord(String s) {
-    int count = 0;
     int idx = s.length() - 1;
     while (idx >= 0 && s.charAt(idx) == ' ') {
       idx--;
     }
+    int currIdx = idx;
     while (idx >= 0 && s.charAt(idx) != ' ') {
       idx--;
-      count++;
     }
-    return count;
+    return currIdx - idx;
   }
 }

From dd55b2cad1276372f0c3f3d0ca0ca37eba1eab15 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 1 Jul 2022 08:21:00 -0700
Subject: [PATCH 1121/2175] Update Remove Duplicates from Sorted Array.java

---
 Easy/Remove Duplicates from Sorted Array.java | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/Easy/Remove Duplicates from Sorted Array.java b/Easy/Remove Duplicates from Sorted Array.java
index 7349f2f2..7c285a36 100644
--- a/Easy/Remove Duplicates from Sorted Array.java	
+++ b/Easy/Remove Duplicates from Sorted Array.java	
@@ -1,15 +1,14 @@
 class Solution {
   public int removeDuplicates(int[] nums) {
-    int start = 0;
-    int end = 0;
-    int n = nums.length;
-    while (end < n) {
-      int curr = nums[end];
-      while (end < n && nums[end] == curr) {
-        end++;
+    int startIdx = 0;
+    int endIdx = 0;
+    while (endIdx < nums.length) {
+      int currValue = nums[endIdx];
+      while (endIdx < nums.length && nums[endIdx] == currValue) {
+        endIdx++;
       }
-      nums[start++] = curr;
+      nums[startIdx++] = currValue;
     }
-    return start;
+    return startIdx;
   }
 }

From c7d73da2e2b5fc1f430fd4a19d7e966c7ec53ee0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 1 Jul 2022 08:45:05 -0700
Subject: [PATCH 1122/2175] Update N-ary Tree Postorder Traversal.java

---
 Easy/N-ary Tree Postorder Traversal.java | 47 ++++++++++--------------
 1 file changed, 20 insertions(+), 27 deletions(-)

diff --git a/Easy/N-ary Tree Postorder Traversal.java b/Easy/N-ary Tree Postorder Traversal.java
index d0ba1138..3807c509 100644
--- a/Easy/N-ary Tree Postorder Traversal.java	
+++ b/Easy/N-ary Tree Postorder Traversal.java	
@@ -6,38 +6,31 @@ class Node {
 
     public Node() {}
 
-    public Node(int _val,List<Node> _children) {
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
         val = _val;
         children = _children;
     }
 };
 */
-class Solution {
-    public List<Integer> postorder(Node root) {
-        List<Integer> values = new ArrayList<>();
-        if (root == null) {
-            return values;
-        }
-        
-        
-        Stack<Node> stack1 = new Stack<>();
-        Stack<Node> stack2 = new Stack<>();
 
-        stack1.push(root);
-
-        while (!stack1.empty()) {
-            Node temp = stack1.pop();
-            stack2.push(temp);
-            List<Node> childrens = temp.children;
-            for(Node children : childrens) {
-                stack1.push(children);
-            }
-        }
-
-        while (!stack2.empty()) {
-            values.add(stack2.pop().val);
-        }
-        
-        return values;
+class Solution {
+  public List<Integer> postorder(Node root) {
+    List<Integer> result = new ArrayList<>();
+    helper(root, result);
+    return result;
+  } 
+  
+  private void helper(Node root, List<Integer> result) {
+    if (root == null) {
+      return;
+    }
+    for (Node child : root.children) {
+      helper(child, result);
     }
+    result.add(root.val);
+  }
 }

From 57f26849e8320d54455620b3190569d59c68deb3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 1 Jul 2022 13:36:48 -0700
Subject: [PATCH 1123/2175] Update 4Sum.java

---
 Medium/4Sum.java | 55 +++++++++++++++++++++++++++++++++---------------
 1 file changed, 38 insertions(+), 17 deletions(-)

diff --git a/Medium/4Sum.java b/Medium/4Sum.java
index 41f71e4a..50832c2c 100644
--- a/Medium/4Sum.java
+++ b/Medium/4Sum.java
@@ -1,25 +1,46 @@
 class Solution {
   public List<List<Integer>> fourSum(int[] nums, int target) {
     Arrays.sort(nums);
-    Set<List<Integer>> set = new HashSet<>();
-    for (int i = 0; i < nums.length; i++) {
-      for (int j = i + 1; j < nums.length; j++) {
-        int newTarget = target - nums[i] - nums[j];
-        int start = j + 1;
-        int end = nums.length - 1;
-        while (start < end) {
-          if ((nums[start] + nums[end]) == newTarget) {
-            set.add(Arrays.asList(nums[i], nums[j], nums[start++], nums[end--]));
-          }
-          else if ((nums[start] + nums[end]) < newTarget) {
-            start++;
-          }
-          else {
-            end--;
-          }
+    return kSum(nums, target, 0, 4);
+  }
+  
+  public List<List<Integer>> kSum(int[] nums, long target, int start, int k) {
+    List<List<Integer>> result = new ArrayList<>();
+    if (start == nums.length) {
+      return result;
+    }
+    long averageValue = target / k;
+    if  (nums[start] > averageValue || averageValue > nums[nums.length - 1]) {
+      return result;
+    }
+    if (k == 2) {
+      return twoSum(nums, target, start);
+    }
+    for (int i = start; i < nums.length; ++i) {
+      if (i == start || nums[i - 1] != nums[i]) {
+        for (List<Integer> subset : kSum(nums, target - nums[i], i + 1, k - 1)) {
+          result.add(new ArrayList<>(Arrays.asList(nums[i])));
+          result.get(result.size() - 1).addAll(subset);
         }
       }
     }
-    return new ArrayList<>(set);
+    return result;
+  }
+	
+  public List<List<Integer>> twoSum(int[] nums, long target, int start) {
+    List<List<Integer>> result = new ArrayList<>();
+    int low = start;
+    int high = nums.length - 1;
+    while (low < high) {
+      int currSum = nums[low] + nums[high];
+      if (currSum < target || (low > start && nums[low] == nums[low - 1])) {
+        ++low;
+      } else if (currSum > target || (high < nums.length - 1 && nums[high] == nums[high + 1])) {
+        --high;
+      } else {
+        result.add(Arrays.asList(nums[low++], nums[high--]));
+      }
+    }
+    return result;
   }
 }

From dab3fd0082e8cccdfe3639851115104291c9a13a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Jul 2022 11:00:26 -0700
Subject: [PATCH 1124/2175] Create Maximum Area of a Piece of Cake After
 Horizontal and Vertical Cuts.java

---
 ...Cake After Horizontal and Vertical Cuts.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts.java

diff --git a/Medium/Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts.java b/Medium/Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts.java
new file mode 100644
index 00000000..e723cd7e
--- /dev/null
+++ b/Medium/Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int maxArea(int h, int w, int[] horizontalCuts, int[] verticalCuts) {
+    Arrays.sort(horizontalCuts);
+    Arrays.sort(verticalCuts);
+    int n = horizontalCuts.length;
+    int m = verticalCuts.length;
+    long maxHeight = Math.max(horizontalCuts[0], h - horizontalCuts[n - 1]);
+    for (int i = 1; i < n; i++) {
+      maxHeight = Math.max(maxHeight, horizontalCuts[i] - horizontalCuts[i - 1]);
+    }
+    long maxWidth = Math.max(verticalCuts[0], w - verticalCuts[m - 1]);
+    for (int i = 1; i < m; i++) {
+      maxWidth = Math.max(maxWidth, verticalCuts[i] - verticalCuts[i - 1]);
+    }
+    return (int) ((maxWidth * maxHeight) % (1000000007));
+  }
+}

From 1c68634abe5ca2fb64f9cf608efae2a9a0d90e0f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Jul 2022 15:44:03 -0700
Subject: [PATCH 1125/2175] Create Wiggle Subsequence.java

---
 Medium/Wiggle Subsequence.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Wiggle Subsequence.java

diff --git a/Medium/Wiggle Subsequence.java b/Medium/Wiggle Subsequence.java
new file mode 100644
index 00000000..4e066527
--- /dev/null
+++ b/Medium/Wiggle Subsequence.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int wiggleMaxLength(int[] nums) {
+    if (nums.length < 2) {
+      return nums.length;
+    }
+    int[] increasing = new int[nums.length];
+    int[] decreasing = new int[nums.length];
+    for (int i = 0; i < nums.length; i++) {
+      for (int j = 0; j < i; j++) {
+        if (nums[i] > nums[j]) {
+          increasing[i] = Math.max(increasing[i], decreasing[j] + 1);
+        } else if (nums[i] < nums[j]) {
+          decreasing[i] = Math.max(decreasing[i], increasing[j] + 1);
+        }
+      }
+    }
+    return 1 + Math.max(decreasing[nums.length - 1], increasing[nums.length - 1]);
+  }
+}

From 45442bb1411d2a9ae0464a2fea2bc2cd0342ff69 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Jul 2022 20:52:55 -0700
Subject: [PATCH 1126/2175] Create Decode the Message.java

---
 Easy/Decode the Message.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Decode the Message.java

diff --git a/Easy/Decode the Message.java b/Easy/Decode the Message.java
new file mode 100644
index 00000000..c7396320
--- /dev/null
+++ b/Easy/Decode the Message.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public String decodeMessage(String key, String message) {
+    int counter = 0;
+    Map<Character, Character> map = new HashMap<>();
+    for (char c : key.toCharArray()) {
+      if (!map.containsKey(c) && c != ' ') {
+        map.put(c, (char) ('a' + counter++));
+      }
+    }
+    StringBuilder sb = new StringBuilder();
+    for (char c : message.toCharArray()) {
+      sb.append(c == ' ' ? ' ' : map.get(c));
+    }
+    return sb.toString();
+  }
+}

From 7412f6fb01df2b0dacb2494452534b865c4a2cad Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Jul 2022 14:06:43 -0700
Subject: [PATCH 1127/2175] Update Candy.java

---
 Hard/Candy.java | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/Hard/Candy.java b/Hard/Candy.java
index ed787668..5bf67db1 100644
--- a/Hard/Candy.java
+++ b/Hard/Candy.java
@@ -1,23 +1,19 @@
 class Solution {
   public int candy(int[] ratings) {
-    int[] leftCandy = new int[ratings.length];
-    int[] rightCandy = new int[ratings.length];
-    Arrays.fill(leftCandy, 1);
-    Arrays.fill(rightCandy, 1);
+    int[] candies = new int[ratings.length];
+    Arrays.fill(candies, 1);
     for (int i = 1; i < ratings.length; i++) {
       if (ratings[i] > ratings[i - 1]) {
-        leftCandy[i] = leftCandy[i - 1] + 1;
+        candies[i] = candies[i - 1] + 1;
       }
     }
+    int totalCandies = candies[candies.length - 1];
     for (int i = ratings.length - 2; i >= 0; i--) {
       if (ratings[i] > ratings[i + 1]) {
-        rightCandy[i] = rightCandy[i + 1] + 1;
+        candies[i] = Math.max(candies[i], candies[i + 1] + 1);
       }
+      totalCandies += candies[i];
     }
-    int numOfCandies = 0;
-    for (int i = 0; i < ratings.length; i++) {
-      numOfCandies += Math.max(leftCandy[i], rightCandy[i]);
-    }
-    return numOfCandies; 
+    return totalCandies;
   }
 }

From d27b620e65e96a771b84e88509b321289a37bfba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Jul 2022 18:05:16 -0700
Subject: [PATCH 1128/2175] Update Longest Consecutive Sequence.java

---
 Medium/Longest Consecutive Sequence.java | 26 +++++++++++++-----------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/Medium/Longest Consecutive Sequence.java b/Medium/Longest Consecutive Sequence.java
index 0549b6e6..e977e86a 100644
--- a/Medium/Longest Consecutive Sequence.java	
+++ b/Medium/Longest Consecutive Sequence.java	
@@ -1,19 +1,21 @@
 class Solution {
   public int longestConsecutive(int[] nums) {
-    Map<Integer, Integer> map = new HashMap<>();
-    int maxLength = 0;
+    Set<Integer> set = new HashSet<>();
     for (int num : nums) {
-      if (map.containsKey(num)) {
-        continue;
+      set.add(num);
+    }
+    int maxLength = 0;
+    for (int num : set) {
+      if (!set.contains(num - 1)) {
+        int currNum = num;
+        int currentLength = 1;
+        while (set.contains(currNum + 1)) {
+          currNum++;
+          currentLength++;
+        }
+        maxLength = Math.max(currentLength, maxLength);
       }
-      int left = map.containsKey(num - 1) ? map.get(num - 1) : 0;
-      int right = map.containsKey(num + 1) ? map.get(num + 1) : 0;
-      int sum = left + right + 1;
-      maxLength = Math.max(maxLength, sum);
-      map.put(num, sum);
-      map.put(num - left, sum);
-      map.put(num + right, sum);
     }
     return maxLength;
-  }   
+  }
 }

From 872f1f472b532942d361012b703c14f09e2fb8ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Jul 2022 07:51:59 -0700
Subject: [PATCH 1129/2175] Update Validate Binary Search Tree.java

---
 Medium/Validate Binary Search Tree.java | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/Medium/Validate Binary Search Tree.java b/Medium/Validate Binary Search Tree.java
index b7d2a9f7..7989ffbf 100644
--- a/Medium/Validate Binary Search Tree.java	
+++ b/Medium/Validate Binary Search Tree.java	
@@ -4,23 +4,27 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public boolean isValidBST(TreeNode root) {
-    long min = (long) Integer.MIN_VALUE;
-    long max = (long) Integer.MAX_VALUE;
-    return helper(root, min - 1, max + 1);
+    return isValidBSTHelper(root, (((long) Integer.MAX_VALUE)  + 1), ((long) Integer.MIN_VALUE) - 1);
   }
   
-  private boolean helper(TreeNode root, long min, long max) {
-    if (root == null) {
+  private boolean isValidBSTHelper(TreeNode node, long max, long min) {
+    if (node == null) {
       return true;
     }
-    if (root.val <= min || root.val >= max) {
+    if (node.val >= max || node.val <= min) {
       return false;
     }
-    return helper(root.left, min, (long) root.val) && helper(root.right, (long) root.val, max);
+    return isValidBSTHelper(node.left, node.val, min) && isValidBSTHelper(node.right, max, node.val);
   }
 }

From 81e6e850812cc9677950ff2029a46e453627adb6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Jul 2022 08:59:51 -0700
Subject: [PATCH 1130/2175] Update Compare Version Numbers.java

---
 Medium/Compare Version Numbers.java | 42 ++++++++++++-----------------
 1 file changed, 17 insertions(+), 25 deletions(-)

diff --git a/Medium/Compare Version Numbers.java b/Medium/Compare Version Numbers.java
index 94e1e7ed..b7b13684 100644
--- a/Medium/Compare Version Numbers.java	
+++ b/Medium/Compare Version Numbers.java	
@@ -1,33 +1,25 @@
 class Solution {
   public int compareVersion(String version1, String version2) {
-    String[] versionOneSplit = version1.split("\\.");
-    String[] versionTwoSplit = version2.split("\\.");
-    int idxOne = 0;
-    int idxTwo = 0;
-    while (idxOne < versionOneSplit.length && idxTwo < versionTwoSplit.length) {
-      int diff = Integer.parseInt(versionOneSplit[idxOne]) - Integer.parseInt(versionTwoSplit[idxTwo]);
-      if (diff < 0) {
-        return -1;
-      } else if (diff > 0) {
-        return 1;
+    String[] splitOne = version1.split("\\.");
+    String[] splitTwo = version2.split("\\.");
+    int i = 0;
+    for (i = 0; i < Math.min(splitOne.length, splitTwo.length); i++) {
+      int diff = Integer.parseInt(splitOne[i]) - Integer.parseInt(splitTwo[i]);
+      if (diff == 0) {
+        continue;
       }
-      idxOne++;
-      idxTwo++;
+      return diff < 0 ? -1 : 1;
     }
-    if (containsNonZeroRevision(versionOneSplit, idxOne)) {
-      return 1;
-    } else if (containsNonZeroRevision(versionTwoSplit, idxTwo)) {
-      return -1;
+    while (i < splitOne.length) {
+      if (Integer.parseInt(splitOne[i++]) > 0) {
+        return 1;
+      }
     }
-    return 0;
-  }
-  
-  private boolean containsNonZeroRevision(String[] versions, int idx) {
-    for (int i = idx; i < versions.length; i++) {
-      if (Integer.parseInt(versions[i]) > 0) {
-        return true;
+    while (i < splitTwo.length) {
+      if (Integer.parseInt(splitTwo[i++]) > 0) {
+        return -1;
       }
     }
-    return false;
-  }
+    return 0;
+  } 
 }

From c677a7edbdff3a04a93ff027edf16e3ea628ab6a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Jul 2022 09:43:26 -0700
Subject: [PATCH 1131/2175] Update Happy Number.java

---
 Easy/Happy Number.java | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/Easy/Happy Number.java b/Easy/Happy Number.java
index 13adce96..0884e3a1 100644
--- a/Easy/Happy Number.java	
+++ b/Easy/Happy Number.java	
@@ -1,27 +1,21 @@
 class Solution {
   public boolean isHappy(int n) {
-    Set<Integer> set = new HashSet<>();
-    set.add(n);
-    while (true) {
-      int sumOfDigitSquare = getSumOfDigitSquare(n);
-      if (sumOfDigitSquare == 1) {
-        return true;
-      }
-      if (set.contains(sumOfDigitSquare)) {
-        break;
-      }
-      set.add(sumOfDigitSquare);
-      n = sumOfDigitSquare;
+    int slow = n;
+    int fast = getSquareDigitSum(n);
+    while (fast != 1 && slow != fast) {
+      slow = getSquareDigitSum(slow);
+      fast = getSquareDigitSum(getSquareDigitSum(fast));
     }
-    return false;
+    return fast == 1;
   }
   
-  private int getSumOfDigitSquare(int n) {
-    int sum = 0;
+  private int getSquareDigitSum(int n) {
+    int squareDigitSum = 0;
     while (n > 0) {
-      sum += (int) Math.pow(n % 10, 2);
+      int digit = n % 10;
+      squareDigitSum += digit * digit;
       n /= 10;
     }
-    return sum;
+    return squareDigitSum;
   }
 }

From f0f604e7b6f076d496e9480ca29545f370cc940c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Jul 2022 09:47:43 -0700
Subject: [PATCH 1132/2175] Update SqrtX.java

---
 Easy/SqrtX.java | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/Easy/SqrtX.java b/Easy/SqrtX.java
index 51c13b9c..9c96e058 100644
--- a/Easy/SqrtX.java
+++ b/Easy/SqrtX.java
@@ -3,21 +3,19 @@ public int mySqrt(int x) {
     if (x < 2) {
       return x;
     }
-    int start = 2;
-    int end = x / 2;
-    while (start <= end) {
-      int mid = start + (end - start) / 2;
-      long num = (long) mid * mid; 
-      if (num > x) {
-        end = mid - 1;
-      }
-      else if (num < x) {
-        start = mid + 1;
-      }
-      else {
+    int left = 2;
+    int right = x / 2;
+    while (left <= right) {
+      int mid = (left + right) / 2;
+      long square = ((long) mid) * mid; 
+      if (square > x) {
+        right = mid - 1;
+      } else if (square < x) {
+        left = mid + 1;
+      } else {
         return mid;
       }
     }
-    return end;
+    return right;
   }
 }

From aebc34bf7163981d905898dd7b7d27a4290f7f2c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Jul 2022 08:35:19 -0700
Subject: [PATCH 1133/2175] Rename Easy/Min Stack.java to Medium/Min Stack.java

---
 {Easy => Medium}/Min Stack.java | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {Easy => Medium}/Min Stack.java (100%)

diff --git a/Easy/Min Stack.java b/Medium/Min Stack.java
similarity index 100%
rename from Easy/Min Stack.java
rename to Medium/Min Stack.java

From b6210ddd918942c97dc045886cfdf8f096a4fbc4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Jul 2022 09:28:26 -0700
Subject: [PATCH 1134/2175] Update and rename Hard/Interleaving String.java to
 Medium/Interleaving String.java

---
 Hard/Interleaving String.java   | 33 ---------------------------------
 Medium/Interleaving String.java | 24 ++++++++++++++++++++++++
 2 files changed, 24 insertions(+), 33 deletions(-)
 delete mode 100644 Hard/Interleaving String.java
 create mode 100644 Medium/Interleaving String.java

diff --git a/Hard/Interleaving String.java b/Hard/Interleaving String.java
deleted file mode 100644
index 3fd73eb2..00000000
--- a/Hard/Interleaving String.java	
+++ /dev/null
@@ -1,33 +0,0 @@
-class Solution {
-    public boolean isInterleave(String s1, String s2, String s3) {
-        if (s1.length()+s2.length() != s3.length()) {
-            return false;
-        }
-
-        boolean[][] dp = new boolean[s1.length()+1][s2.length()+1];
-
-        dp[0][0] = true;
-
-        for (int i = 0; i <= s1.length(); i++){
-            for (int j = 0; j <= s2.length(); j++){
-                boolean s1Check = false;
-                boolean s2Check = false;
-
-                if (i > 0) {
-                    s1Check = dp[i-1][j] && s3.charAt(i+j-1) == s1.charAt(i-1);
-                }
-
-                if (j > 0) {
-                    s2Check = dp[i][j-1] && s3.charAt(i+j-1) == s2.charAt(j-1);
-                }
-
-                if (i>0 || j>0) {
-                    dp[i][j] = s1Check || s2Check;
-                }
-            }
-        }
-
-
-        return dp[s1.length()][s2.length()];
-    }
-}
diff --git a/Medium/Interleaving String.java b/Medium/Interleaving String.java
new file mode 100644
index 00000000..6e4408ce
--- /dev/null
+++ b/Medium/Interleaving String.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public boolean isInterleave(String s1, String s2, String s3) {
+    if (s1.length() + s2.length() != s3.length()) {
+      return false;
+    }
+    Boolean[][] dp = new Boolean[s1.length()][s2.length()];
+    return isInterleaveHelper(s1, 0, s2, 0, s3, 0, dp);
+  }
+  
+  private boolean isInterleaveHelper(String s1, int i1, String s2, int i2, String s3, int i3, Boolean[][] dp) {
+    if (i1 == s1.length()) {
+      return s2.substring(i2).equals(s3.substring(i3));
+    }
+    if (i2 == s2.length()) {
+      return s1.substring(i1).equals(s3.substring(i3));
+    }
+    if (dp[i1][i2] != null) {
+      return dp[i1][i2]; 
+    }
+    dp[i1][i2] = (s3.charAt(i3) == s1.charAt(i1) && isInterleaveHelper(s1, i1 + 1, s2, i2, s3, i3 + 1, dp)) || 
+                 (s3.charAt(i3) == s2.charAt(i2) && isInterleaveHelper(s1, i1, s2, i2 + 1, s3, i3 + 1, dp));
+    return dp[i1][i2];
+  }
+}

From dd8dd6550cf77a7968aaca41151a1c29b68736b1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Jul 2022 10:51:25 -0700
Subject: [PATCH 1135/2175] Create Longest Arithmetic Subsequence.java

---
 Medium/Longest Arithmetic Subsequence.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Longest Arithmetic Subsequence.java

diff --git a/Medium/Longest Arithmetic Subsequence.java b/Medium/Longest Arithmetic Subsequence.java
new file mode 100644
index 00000000..70544ee4
--- /dev/null
+++ b/Medium/Longest Arithmetic Subsequence.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int longestArithSeqLength(int[] nums) {
+    int result = 2;
+    Map<Integer, Integer>[] dp = new HashMap[nums.length];
+    for (int i = 0; i < nums.length; i++) {
+      dp[i] = new HashMap<>();
+      for (int j = 0; j < i; j++) {
+        int diff = nums[i] - nums[j];
+        dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1);
+        result = Math.max(result, dp[i].get(diff));
+      }
+    }
+    return result;
+  }
+}

From d4cd4cf44a9899b80633593e833047971a6a5f7a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Jul 2022 12:36:50 -0700
Subject: [PATCH 1136/2175] Update Binary Search.java

---
 Easy/Binary Search.java | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/Easy/Binary Search.java b/Easy/Binary Search.java
index 8fac5829..0acaa8aa 100644
--- a/Easy/Binary Search.java	
+++ b/Easy/Binary Search.java	
@@ -1,17 +1,15 @@
 class Solution {
   public int search(int[] nums, int target) {
-    int left = 0;
-    int right = nums.length - 1;
-    while (left <= right) {
-      int mid = (left + right) / 2;
+    int start = 0;
+    int end = nums.length - 1;
+    while (start <= end) {
+      int mid = (start + end) / 2;
       if (nums[mid] == target) {
         return mid;
-      }
-      else if (nums[mid] > target) {
-        right = mid - 1;
-      }
-      else {
-        left = mid + 1;
+      } else if (nums[mid] < target) {
+        start = mid + 1;
+      } else {
+        end = mid - 1;
       }
     }
     return -1;

From 36e6dcbb36577f826842eec1c91253411549b533 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 8 Jul 2022 10:40:57 -0700
Subject: [PATCH 1137/2175] Create Paint House III.java

---
 Hard/Paint House III.java | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Hard/Paint House III.java

diff --git a/Hard/Paint House III.java b/Hard/Paint House III.java
new file mode 100644
index 00000000..461973f0
--- /dev/null
+++ b/Hard/Paint House III.java	
@@ -0,0 +1,37 @@
+class Solution {
+  private static final int MAXIMUM_POSSIBLE_COST = 1000001;
+  
+  public int minCost(int[] houses, int[][] cost, int m, int n, int target) {
+    Integer[][][] dp = new Integer[m + 1][target + 1][n + 1]; // [Current House][Neighborhood Count][Previous Color]
+    int result = helper(houses, cost, target, 0, 0, dp);
+    return result == MAXIMUM_POSSIBLE_COST ? -1 : result;
+  }
+  
+  public int helper(int[] houses, int[][] cost, int target, int idx, int numOfNeighbourhood, Integer[][][] dp) {
+    if (idx == houses.length) {
+      return numOfNeighbourhood != target ? MAXIMUM_POSSIBLE_COST : 0;
+    }
+    if (numOfNeighbourhood > target) {
+      return MAXIMUM_POSSIBLE_COST;
+    }
+    int prevHouseColor = idx == 0 ? 0 : houses[idx - 1];
+    if (dp[idx][numOfNeighbourhood][prevHouseColor] != null) {
+      return dp[idx][numOfNeighbourhood][prevHouseColor];
+    }
+    int minimumCost = MAXIMUM_POSSIBLE_COST;
+    if (houses[idx] != 0) {
+      int currColor = houses[idx];
+      int updatedNumOfNeighbourhood = currColor != prevHouseColor ? numOfNeighbourhood + 1 : numOfNeighbourhood;
+      minimumCost = helper(houses, cost, target, idx + 1, updatedNumOfNeighbourhood, dp);
+    } else {
+      for (int currentColor = 1; currentColor <= cost[idx].length; currentColor++) {
+        houses[idx] = currentColor; // Color the house with currentColor
+        int updatedNumOfNeighbourhood = currentColor != prevHouseColor ? numOfNeighbourhood + 1 : numOfNeighbourhood;
+        int currCost = cost[idx][currentColor - 1] + helper(houses, cost, target, idx + 1, updatedNumOfNeighbourhood, dp);
+        minimumCost = Math.min(minimumCost, currCost);
+        houses[idx] = 0; // Remove the currentColor for recursion
+      }
+    }
+    return dp[idx][numOfNeighbourhood][prevHouseColor] = minimumCost;
+  }
+}

From 4c797fc2af271797e7366b16bee5fc0549e7c8f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 8 Jul 2022 11:17:56 -0700
Subject: [PATCH 1138/2175] Update Squares of a Sorted Array.java

---
 Easy/Squares of a Sorted Array.java | 36 ++++++++++++-----------------
 1 file changed, 15 insertions(+), 21 deletions(-)

diff --git a/Easy/Squares of a Sorted Array.java b/Easy/Squares of a Sorted Array.java
index 5308f168..046fcf9c 100644
--- a/Easy/Squares of a Sorted Array.java	
+++ b/Easy/Squares of a Sorted Array.java	
@@ -1,30 +1,24 @@
 class Solution {
   public int[] sortedSquares(int[] nums) {
-    int firstNegativeIdx = nums[0] < 0 ? 0 : nums.length;
-    int lastPositiveIdx = nums[nums.length - 1] >= 0 ? nums.length - 1 : -1;
+    int negativeIdx = 0;
+    int positiveIdx = nums.length - 1;
     int[] result = new int[nums.length];
-    int idx = result.length - 1;
-    while (idx >= 0) {
-      if (firstNegativeIdx < nums.length && lastPositiveIdx >= 0) {
-        if (Math.abs(nums[firstNegativeIdx]) > nums[lastPositiveIdx]) {
-          result[idx--] = nums[firstNegativeIdx] * nums[firstNegativeIdx];
-          firstNegativeIdx++;
-          if (firstNegativeIdx < nums.length && nums[firstNegativeIdx] >= 0) {
-            firstNegativeIdx = nums.length;
-          }
+    int resultIdx = nums.length - 1;
+    while(resultIdx >= 0) {
+      if (nums[negativeIdx] < 0 && nums[positiveIdx] >= 0) {
+        if (Math.abs(nums[negativeIdx]) > nums[positiveIdx]) {
+          result[resultIdx--] = nums[negativeIdx] * nums[negativeIdx];
+          negativeIdx++;
         } else {
-          result[idx--] = nums[lastPositiveIdx] * nums[lastPositiveIdx];
-          lastPositiveIdx--;
-          if (lastPositiveIdx >= 0 && nums[lastPositiveIdx] < 0) {
-            lastPositiveIdx = -1;
-          }
+          result[resultIdx--] = nums[positiveIdx] * nums[positiveIdx];
+          positiveIdx--;
         }
-      } else if (firstNegativeIdx < nums.length && lastPositiveIdx < 0) {
-          result[idx--] = nums[firstNegativeIdx] * nums[firstNegativeIdx];
-          firstNegativeIdx++;
+      } else if (nums[negativeIdx] < 0 && nums[positiveIdx] < 0) {
+        result[resultIdx--] = nums[negativeIdx] * nums[negativeIdx];
+        negativeIdx++;
       } else {
-          result[idx--] = nums[lastPositiveIdx] * nums[lastPositiveIdx];
-          lastPositiveIdx--;
+        result[resultIdx--] = nums[positiveIdx] * nums[positiveIdx];
+        positiveIdx--;  
       }
     }
     return result;

From d5fc12e90c73353a301001749f6ef455b718fa4d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Jul 2022 09:31:12 -0700
Subject: [PATCH 1139/2175] Create Jump Game VI.java

---
 Medium/Jump Game VI.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Jump Game VI.java

diff --git a/Medium/Jump Game VI.java b/Medium/Jump Game VI.java
new file mode 100644
index 00000000..76ae982c
--- /dev/null
+++ b/Medium/Jump Game VI.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public int maxResult(int[] nums, int k) {
+    int[] score = new int[nums.length];
+    score[0] = nums[0];
+    PriorityQueue<int[]> queue = new PriorityQueue<>((a, b) -> b[0] - a[0]);
+    queue.add(new int[]{nums[0], 0});
+    for (int i = 1; i < nums.length; i++) {
+      while (!queue.isEmpty() && queue.peek()[1] < i - k) {
+        queue.remove();
+      }
+      score[i] = score[queue.peek()[1]] + nums[i];
+      queue.add(new int[]{score[i], i});
+    }
+    return score[nums.length - 1];
+  }
+}

From 4bc2eeb74854d4b5c98918e651c7213ea98a78ee Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Jul 2022 09:40:25 -0700
Subject: [PATCH 1140/2175] Create Evaluate Boolean Binary Tree.java

---
 Easy/Evaluate Boolean Binary Tree.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Evaluate Boolean Binary Tree.java

diff --git a/Easy/Evaluate Boolean Binary Tree.java b/Easy/Evaluate Boolean Binary Tree.java
new file mode 100644
index 00000000..39b6edac
--- /dev/null
+++ b/Easy/Evaluate Boolean Binary Tree.java	
@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public boolean evaluateTree(TreeNode root) {
+    if (root.val == 0 || root.val == 1) {
+      return root.val == 0 ? false : true;
+    }
+    return root.val == 2 ? (evaluateTree(root.left) || evaluateTree(root.right)) : (evaluateTree(root.left) && evaluateTree(root.right));
+  }
+}

From 931f2382e192fcac98c57c8dd40f6d1e4d79b57c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Jul 2022 15:59:01 -0700
Subject: [PATCH 1141/2175] Update Valid Perfect Square.java

---
 Easy/Valid Perfect Square.java | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Easy/Valid Perfect Square.java b/Easy/Valid Perfect Square.java
index ec870dd1..16c1a509 100644
--- a/Easy/Valid Perfect Square.java	
+++ b/Easy/Valid Perfect Square.java	
@@ -1,22 +1,22 @@
 class Solution {
   public boolean isPerfectSquare(int num) {
-    return binarySearchHelper((long)1, (long)num, num) == -1 ? false : true;
-  }
-  
-  private int binarySearchHelper(long start, long end, int num) {
+    if (num == 1) {
+      return true;
+    }
+    long start = 2;
+    long end = num / 2;
     while (start <= end) {
-      long mid = (start + end) / 2;
-      long square = (long) Math.pow(mid, 2);
-      if (square == num) {
-        return (int) mid;
+      long mid = start + (end - start) / 2;
+      long currSquare = mid * mid;
+      if (currSquare == num) {
+        return true;
       }
-      else if (square > num) {
+      if (currSquare > num) {
         end = mid - 1;
-      }
-      else {
+      } else {
         start = mid + 1;
       }
     }
-    return -1;
+    return false;
   }
 }

From 8ade91524a188a7f382f28ca49fefd216cde83d9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Jul 2022 16:19:49 -0700
Subject: [PATCH 1142/2175] Update Find the Distance Value Between Two
 Arrays.java

---
 ...the Distance Value Between Two Arrays.java | 32 ++++++++++++-------
 1 file changed, 21 insertions(+), 11 deletions(-)

diff --git a/Easy/Find the Distance Value Between Two Arrays.java b/Easy/Find the Distance Value Between Two Arrays.java
index 69df4f37..0fb09098 100644
--- a/Easy/Find the Distance Value Between Two Arrays.java	
+++ b/Easy/Find the Distance Value Between Two Arrays.java	
@@ -1,18 +1,28 @@
 class Solution {
   public int findTheDistanceValue(int[] arr1, int[] arr2, int d) {
-    TreeSet<Integer> set = new TreeSet<>();
-    for (int num : arr2) {
-      set.add(num);
+    Arrays.sort(arr2);
+    int distance = 0;
+    for (int i = 0; i < arr1.length; i++) {
+      if (outsideRange(arr2, arr1[i] - d, arr1[i] + d)) {
+        distance++;
+      }
     }
-    int count = 0;
-    for (int num : arr1) {
-      Integer higher = set.ceiling(num);
-      Integer lower = set.floor(num);
-      if ((higher != null && Math.abs(higher - num) <= d) || (lower != null && Math.abs(lower - num) <= d)) {
-        continue;  
+    return distance;
+  }
+  
+  private static boolean outsideRange(int[] arr, int from, int to) {
+    int start = 0;
+    int end = arr.length - 1;
+    while (start <= end) {
+      int mid = start + (end - start) / 2;
+      if (arr[mid] >= from && arr[mid] <= to) {
+        return false;
+      } else if (arr[mid] < from) {
+        start = mid + 1;
+      } else {
+        end = mid - 1;
       }
-      count++;
     }
-    return count;
+    return true;
   }
 }

From d49add8e433b3b30987d86c55fd38487d260018d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Jul 2022 08:27:55 -0700
Subject: [PATCH 1143/2175] Create Minimum Amount of Time to Fill Cups.java

---
 Easy/Minimum Amount of Time to Fill Cups.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Minimum Amount of Time to Fill Cups.java

diff --git a/Easy/Minimum Amount of Time to Fill Cups.java b/Easy/Minimum Amount of Time to Fill Cups.java
new file mode 100644
index 00000000..b772c001
--- /dev/null
+++ b/Easy/Minimum Amount of Time to Fill Cups.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int fillCups(int[] amount) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+    for (int count : amount) {
+      updateQueue(pq, count);
+    }
+    int totalTime = 0;
+    while (!pq.isEmpty()) {
+      int removedOne = pq.poll();
+      int removedTwo = pq.isEmpty() ? 0 : pq.poll();
+      removedOne--;
+      removedTwo--;
+      updateQueue(pq, removedOne);
+      updateQueue(pq, removedTwo);
+      totalTime++;
+    }
+    return totalTime;
+  }
+  
+  private void updateQueue(PriorityQueue<Integer> pq, int count) {
+    if (count > 0) {
+      pq.add(count);
+    }
+  }
+}

From 343aa2601654e701bd7e08c590d631e2ccabd4f5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Jul 2022 16:46:27 -0700
Subject: [PATCH 1144/2175] Update Can Place Flowers.java

---
 Easy/Can Place Flowers.java | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/Easy/Can Place Flowers.java b/Easy/Can Place Flowers.java
index df188af0..c5b9df5d 100644
--- a/Easy/Can Place Flowers.java	
+++ b/Easy/Can Place Flowers.java	
@@ -2,15 +2,13 @@ class Solution {
   public boolean canPlaceFlowers(int[] flowerbed, int n) {
     for (int i = 0; i < flowerbed.length && n > 0; i++) {
       if (flowerbed[i] == 0) {
-        if (i == 0 && (i + 1 < flowerbed.length && flowerbed[i + 1] == 0)
-            || flowerbed.length == 1) {
+        if (i == 0 && (flowerbed.length == 1 || flowerbed[i + 1] == 0)) {
           flowerbed[i] = 1;
           n--;
-        } else if (i == flowerbed.length - 1 && i - 1 >= 0 && flowerbed[i - 1] == 0) {
+        } else if (i == flowerbed.length - 1 && flowerbed[i - 1] == 0) {
           flowerbed[i] = 1;
           n--;
-        } else if (i + 1 < flowerbed.length && i - 1 >= 0 && flowerbed[i + 1] == 0
-            && flowerbed[i - 1] == 0) {
+        } else if (i + 1 < flowerbed.length && flowerbed[i + 1] == 0 && i - 1 >= 0 && flowerbed[i - 1] == 0) {
           flowerbed[i] = 1;
           n--;
         }

From f6acbee2e28a476c1392f1f8ce402e2fe582d430 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Jul 2022 16:55:04 -0700
Subject: [PATCH 1145/2175] Update Reverse Substrings Between Each Pair of
 Parentheses.java

---
 ...ings Between Each Pair of Parentheses.java | 31 ++++++++++---------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/Medium/Reverse Substrings Between Each Pair of Parentheses.java b/Medium/Reverse Substrings Between Each Pair of Parentheses.java
index b4bff4b6..b2ecb320 100644
--- a/Medium/Reverse Substrings Between Each Pair of Parentheses.java	
+++ b/Medium/Reverse Substrings Between Each Pair of Parentheses.java	
@@ -1,26 +1,29 @@
 class Solution {
   public String reverseParentheses(String s) {
-    Stack<Integer> opened = new Stack<>();
-    int n = s.length();
-    int[] pair = new int[n];
-    for (int i = 0; i < n; i++) {
+    char[] letters = s.toCharArray();
+    Stack<Integer> stack = new Stack<>();
+    for (int i = 0; i < s.length(); i++) {
       if (s.charAt(i) == '(') {
-        opened.push(i);
+        stack.push(i);
       } else if (s.charAt(i) == ')') {
-        int startIdx = opened.pop();
-        pair[i] = startIdx;
-        pair[startIdx] = i;
+        reverse(letters, stack.pop(), i);
       }
     }
     StringBuilder sb = new StringBuilder();
-    for (int i = 0, jump = 1; i < n; i += jump) {
-      if (s.charAt(i) == '(' || s.charAt(i) == ')') {
-        i = pair[i];
-        jump = -jump;
-      } else {
-        sb.append(s.charAt(i));
+    for (int i = 0; i < letters.length; i++) {
+      if (letters[i] == '(' || letters[i] == ')') {
+        continue;
       }
+      sb.append(letters[i]);
     }
     return sb.toString();
   }
+  
+  private void reverse(char[] letters, int start, int end) {
+    while (start < end) {
+      char temp = letters[start];
+      letters[start++] = letters[end];
+      letters[end--] = temp;
+    }
+  }
 }

From ecb94124c18bbee2103bd68626f99c946df351dc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 12 Jul 2022 07:07:29 -0700
Subject: [PATCH 1146/2175] Create Matchsticks to Square.java

---
 Medium/Matchsticks to Square.java | 32 +++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Matchsticks to Square.java

diff --git a/Medium/Matchsticks to Square.java b/Medium/Matchsticks to Square.java
new file mode 100644
index 00000000..b5de023b
--- /dev/null
+++ b/Medium/Matchsticks to Square.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public boolean makesquare(int[] matchsticks) {
+    int n = matchsticks.length;
+    int sum = 0;
+    for (int stick : matchsticks) {
+      sum += stick;
+    }
+    int possibleSide = sum / 4;
+    if (possibleSide * 4 != sum) {
+      return false;
+    }
+    Arrays.sort(matchsticks);
+    return dfs(new int[4], matchsticks, possibleSide, matchsticks.length - 1);
+  }
+  
+  private boolean dfs(int[] sum, int[] sticks, int possibleSide, int idx) {
+    if (idx == -1) {
+      return sum[0] == sum[1] && sum[1] == sum[2] && sum[2] == sum[3];
+    }
+    int stick = sticks[idx];
+    for (int i = 0; i < 4; i++) {
+      if (sum[i] + stick <= possibleSide) {
+        sum[i] += stick;
+        if (dfs(sum, sticks, possibleSide, idx - 1)) {
+          return true;
+        }
+        sum[i] -= stick;
+      }
+    }
+    return false;
+  }
+}

From 21775562b08f0a8cfae8e866e288a36658112e48 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 12 Jul 2022 08:43:55 -0700
Subject: [PATCH 1147/2175] Update High Five.java

---
 Easy/High Five.java | 54 +++++++++++++++++----------------------------
 1 file changed, 20 insertions(+), 34 deletions(-)

diff --git a/Easy/High Five.java b/Easy/High Five.java
index 31eb4999..86635d5a 100644
--- a/Easy/High Five.java	
+++ b/Easy/High Five.java	
@@ -1,37 +1,23 @@
 class Solution {
-    public int[][] highFive(int[][] items) {
-        final int COUNT = 5;
-        Map<Integer, PriorityQueue<Integer>> map = new HashMap<>();
-        Set<Integer> set = new TreeSet<>();
-
-        for (int[] item : items) {
-            int id = item[0];
-            int score = item[1];
-
-            map.computeIfAbsent(id, k -> new PriorityQueue<>(COUNT, Comparator.naturalOrder())).add(score);
-
-            if (map.get(id).size() > COUNT) {
-                map.get(id).poll();
-            }
-
-            set.add(id);
-        }
-
-        int[][] ans = new int[map.size()][2];
-        int idx = 0;
-        Iterator<Integer> iterator = set.iterator();
-        while (iterator.hasNext()) {
-            int id = iterator.next();
-            PriorityQueue<Integer> scores = map.get(id);
-            int sum = 0;
-
-            while (!scores.isEmpty()) {
-                sum += scores.poll();
-            }
-
-            ans[idx++] = new int[]{id, sum / COUNT};
-        }
-
-        return ans;
+  public int[][] highFive(int[][] items) {
+    Map<Integer, PriorityQueue<Integer>> map = new HashMap<>();
+    for (int[] item : items) {
+      int id = item[0];
+      int score = item[1];
+      map.computeIfAbsent(id, k -> new PriorityQueue<>((a, b) -> b - a)).add(score);
     }
+    int[][] result = new int[map.size()][2];
+    int idx = 0;
+    for (Integer id : map.keySet()) {
+      PriorityQueue<Integer> scoresInOrder = map.get(id);
+      int totalScore = 0;
+      int count = Math.min(5, scoresInOrder.size());
+      for (int i = 0; i < 5 && !scoresInOrder.isEmpty(); i++) {
+        totalScore += scoresInOrder.poll();
+      }
+      result[idx++] = new int[]{id, totalScore / count};
+    }
+    Arrays.sort(result, (a, b) -> a[0] - b[0]);
+    return result;
+  }
 }

From 2ebf6bbc2deb115d6a2187fe24d50c693a46bc87 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 12 Jul 2022 08:47:19 -0700
Subject: [PATCH 1148/2175] Update Boundary of Binary Tree.java

---
 Medium/Boundary of Binary Tree.java | 90 +++++++++++++++++------------
 1 file changed, 54 insertions(+), 36 deletions(-)

diff --git a/Medium/Boundary of Binary Tree.java b/Medium/Boundary of Binary Tree.java
index 565dc467..a6e26f56 100644
--- a/Medium/Boundary of Binary Tree.java	
+++ b/Medium/Boundary of Binary Tree.java	
@@ -4,57 +4,75 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  List<Integer> list;
-  List<Integer> rightVal;
   public List<Integer> boundaryOfBinaryTree(TreeNode root) {
-    list = new ArrayList<>();
-    rightVal = new ArrayList<>();
-    if (root == null) {
-      return list;
+    List<Integer> result = new ArrayList<>();
+    if (!isLeaf(root)) {
+      result.add(root.val);
     }
-    if (root.left == null && root.right == null) {
-      list.add(root.val);
-      return list;
+    if (root.left != null) {
+      addLeft(result, root.left);
     }
-    list.add(root.val);
-    addLeft(root.left);
-    addLeaves(root);
-    addRight(root.right);
-    for (int i = rightVal.size() - 1; i >= 0; i--) {
-      list.add(rightVal.get(i));
+    addLeaves(result, root);
+    if (root.right != null) {
+      addRight(result, root.right);
     }
-    return list;
+    return result;
   }
   
-  private void addLeft(TreeNode left) {
-    if (left == null || (left.left == null && left.right == null)) {
-      return;
+  private void addRight(List<Integer> result, TreeNode node) {
+    Stack<Integer> stack = new Stack<>();
+    while (node != null) {
+      if (!isLeaf(node)) {
+        stack.push(node.val);
+      }
+      if (node.right != null) {
+        node = node.right;
+      } else {
+        node = node.left;
+      }
+    }
+    while (!stack.isEmpty()) {
+      result.add(stack.pop());
     }
-    list.add(left.val);
-    addLeft(left.left == null ? left.right : left.left);
   }
   
-  private void addLeaves(TreeNode root) {
-    if (root == null) {
-      return;
-    }
-    if (root.left == null && root.right == null) {
-      list.add(root.val);
-      return;
+  private void addLeft(List<Integer> result, TreeNode node) {
+    while (node != null) {
+      if (!isLeaf(node)) {
+        result.add(node.val);
+      }
+      if (node.left != null) {
+        node = node.left;
+      } else {
+        node = node.right;
+      }
     }
-    addLeaves(root.left);
-    addLeaves(root.right);
   }
   
-  private void addRight(TreeNode right) {
-    if (right == null || (right.left == null && right.right == null)) {
-      return;
+  private void addLeaves(List<Integer> result, TreeNode root) {
+    if (isLeaf(root)) {
+      result.add(root.val);
+    } else {
+      if (root.left != null) {
+        addLeaves(result, root.left);
+      }
+      if (root.right != null) {
+        addLeaves(result, root.right);
+      }
     }
-    rightVal.add(right.val);
-    addRight(right.right == null ? right.left : right.right);
   }
+  
+  private boolean isLeaf(TreeNode node) {
+    return node.left == null && node.right == null;
+  } 
 }

From ecee7d7f5239c6083cf8301994b42833407a297c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 12 Jul 2022 17:26:30 -0700
Subject: [PATCH 1149/2175] Create Binary Tree Level Order Traversal.java

---
 Medium/Binary Tree Level Order Traversal.java | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Medium/Binary Tree Level Order Traversal.java

diff --git a/Medium/Binary Tree Level Order Traversal.java b/Medium/Binary Tree Level Order Traversal.java
new file mode 100644
index 00000000..84664d71
--- /dev/null
+++ b/Medium/Binary Tree Level Order Traversal.java	
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public List<List<Integer>> levelOrder(TreeNode root) {
+    if (root == null) {
+      return new ArrayList<>();
+    }
+    Queue<TreeNode> queue = new LinkedList<>();
+    List<List<Integer>> result = new ArrayList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      List<Integer> currLevel = new ArrayList<>();
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        currLevel.add(removed.val);
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+      result.add(currLevel);
+    }
+    return result;
+  }
+}

From dc3dc4e1fc580e11eefaa8a2852b4b5cffaa65ac Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Jul 2022 07:42:55 -0700
Subject: [PATCH 1150/2175] Update Valid Palindrome.java

---
 Easy/Valid Palindrome.java | 34 ++++++++++++++++++++++------------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/Easy/Valid Palindrome.java b/Easy/Valid Palindrome.java
index 11b2358a..efc7bd93 100644
--- a/Easy/Valid Palindrome.java	
+++ b/Easy/Valid Palindrome.java	
@@ -3,22 +3,32 @@ public boolean isPalindrome(String s) {
     int startIdx = 0;
     int endIdx = s.length() - 1;
     while (startIdx < endIdx) {
-      if (!Character.isLetterOrDigit(s.charAt(startIdx))) {
+      if (!isAlphanumeric(s.charAt(startIdx))) {
+        startIdx++;
+      } else if (!isAlphanumeric(s.charAt(endIdx))) {
+        endIdx--;
+      } else {
+        if (!areSame(s.charAt(startIdx), s.charAt(endIdx))) {
+          return false;
+        }
         startIdx++;
-        continue;
-      }
-      if (!Character.isLetterOrDigit(s.charAt(endIdx))) {
         endIdx--;
-        continue;
-      }
-      char startChar = Character.isDigit(s.charAt(startIdx)) ? s.charAt(startIdx) : Character.toLowerCase(s.charAt(startIdx));
-      char endChar = Character.isDigit(s.charAt(endIdx)) ? s.charAt(endIdx) : Character.toLowerCase(s.charAt(endIdx));
-      if (startChar != endChar) {
-        return false;
       }
-      startIdx++;
-      endIdx--;
     }
     return true;
   }
+  
+  private boolean areSame(char c1, char c2) {
+    if (Character.isAlphabetic(c1) && Character.isAlphabetic(c2)) {
+      return Character.toLowerCase(c1) == Character.toLowerCase(c2);
+    } else if (Character.isDigit(c1) && Character.isDigit(c2)) {
+      return c1 == c2;
+    } else {
+      return false;
+    }
+  }
+
+  private boolean isAlphanumeric(char c) {
+    return Character.isAlphabetic(c) || Character.isDigit(c);
+  }
 }

From 30ea21bf9a3335c613cfa02d76361abdc41c54c3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Jul 2022 07:43:38 -0700
Subject: [PATCH 1151/2175] Update Valid Palindrome II.java

---
 Easy/Valid Palindrome II.java | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/Easy/Valid Palindrome II.java b/Easy/Valid Palindrome II.java
index a8627315..04a163a0 100644
--- a/Easy/Valid Palindrome II.java	
+++ b/Easy/Valid Palindrome II.java	
@@ -1,22 +1,18 @@
 class Solution {
   public boolean validPalindrome(String s) {
+    return validPalindromeHelper(s, false);
+  }
+  
+  private boolean validPalindromeHelper(String s, boolean deleted) {
     int startIdx = 0;
     int endIdx = s.length() - 1;
     while (startIdx < endIdx) {
       if (s.charAt(startIdx) != s.charAt(endIdx)) {
-        return isPalindromeWithDeletion(s, startIdx + 1, endIdx) || 
-          isPalindromeWithDeletion(s, startIdx, endIdx - 1);
-      }
-      startIdx++;
-      endIdx--;
-    }
-    return true;
-  } 
-  
-  private boolean isPalindromeWithDeletion(String s, int startIdx, int endIdx) {
-    while (startIdx < endIdx) {
-      if (s.charAt(startIdx) != s.charAt(endIdx)) {
-        return false;
+        if (deleted) {
+          return false;
+        }
+        return validPalindromeHelper(s.substring(0, startIdx) + s.substring(startIdx + 1), true) ||
+               validPalindromeHelper(s.substring(0, endIdx) + s.substring(endIdx + 1), true);
       }
       startIdx++;
       endIdx--;

From 83169b90b63fbb458292ef568cc3d9d8bfa09dfc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Jul 2022 07:49:03 -0700
Subject: [PATCH 1152/2175] Create Expression Add Operators.java

---
 Hard/Expression Add Operators.java | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Hard/Expression Add Operators.java

diff --git a/Hard/Expression Add Operators.java b/Hard/Expression Add Operators.java
new file mode 100644
index 00000000..57e56235
--- /dev/null
+++ b/Hard/Expression Add Operators.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public List<String> addOperators(String num, int target) {
+    List<String> result = new ArrayList<>();
+    helper(num, target, "", result, 0, 0, 0);
+    return result;
+  }
+  
+  private void helper(String s, long target, String path, List<String> result, int pos, long calculatedResult, long multed) {
+    if (pos == s.length()) {
+      if (calculatedResult == target) {
+        result.add(new String(path));
+      } 
+      return;
+    }
+    for (int i = pos; i < s.length(); i++) {
+      if (i != pos && s.charAt(pos) == '0') {
+        break;
+      }
+      long curr = Long.parseLong(s.substring(pos, i + 1));
+      if (pos == 0) {
+        helper(s, target, path + curr, result, i + 1, curr, curr);
+      } else {
+          helper(s, target, path + "+" + curr, result, i + 1, calculatedResult + curr, curr);
+          helper(s, target, path + "-" + curr, result, i + 1, calculatedResult - curr, -curr);
+          helper(s, target, path + "*" + curr, result, i + 1, calculatedResult - multed + multed * curr, multed * curr);
+      }
+    }
+  }
+}

From ff07d36f02c78d1c4c8516f1d0b80b2601a6ca68 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Jul 2022 20:06:27 -0700
Subject: [PATCH 1153/2175] Create Construct Binary Tree from Preorder and
 Inorder Traversal.java

---
 ...e from Preorder and Inorder Traversal.java | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 Medium/Construct Binary Tree from Preorder and Inorder Traversal.java

diff --git a/Medium/Construct Binary Tree from Preorder and Inorder Traversal.java b/Medium/Construct Binary Tree from Preorder and Inorder Traversal.java
new file mode 100644
index 00000000..1c2c1083
--- /dev/null
+++ b/Medium/Construct Binary Tree from Preorder and Inorder Traversal.java	
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode buildTree(int[] preorder, int[] inorder) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int[] preorderIndex = {0};
+    for (int i = 0; i < inorder.length; i++) {
+      map.put(inorder[i], i);
+    }
+    return buildTree(preorder, 0, preorder.length - 1, map, preorderIndex);
+  }
+  
+  private TreeNode buildTree(int[] preorder, int left, int right, Map<Integer, Integer> map, int[] preorderIndex) {
+    if (left > right) {
+      return null;
+    }
+    int rootVal = preorder[preorderIndex[0]++];
+    TreeNode root = new TreeNode(rootVal);
+    root.left = buildTree(preorder, left, map.get(rootVal) - 1, map, preorderIndex);
+    root.right = buildTree(preorder, map.get(rootVal) + 1, right, map, preorderIndex);
+    return root;
+  }
+}

From b81d552f52ebbf43b3b250eadffe4100cabb6071 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Jul 2022 15:23:30 -0700
Subject: [PATCH 1154/2175] Update Swap For Longest Repeated Character
 Substring.java

---
 ... Longest Repeated Character Substring.java | 45 ++++++++++++-------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/Medium/Swap For Longest Repeated Character Substring.java b/Medium/Swap For Longest Repeated Character Substring.java
index d09edb22..fd71081e 100644
--- a/Medium/Swap For Longest Repeated Character Substring.java	
+++ b/Medium/Swap For Longest Repeated Character Substring.java	
@@ -1,29 +1,40 @@
 class Solution {
   public int maxRepOpt1(String text) {
-    int[] count = new int[26];
+    int[] frequency = new int[26];
     for (char c : text.toCharArray()) {
-      count[c - 'a']++;
+      frequency[c - 'a']++;
     }
-    int maxCount = 0;
-    int i = 0;
-    while (i < text.length()) {
+    int maxRepeatingLength = 0;
+    for (int i = 0; i < text.length(); i++) {
       char c = text.charAt(i);
-      int curr = i;
-      int currCount = 0;
+      int j = i;
+      int count = 0;
       int diff = 0;
-      // To skip the same characters before we make a swap
-      int swapPoint = i;
-      while (curr < text.length() && (text.charAt(curr) == c || diff == 0) && currCount < count[c - 'a']) {
-        if (text.charAt(curr) != c) {
+      while (j < text.length() && (c == text.charAt(j) || diff == 0) && count < frequency[c - 'a']) {
+        if (c != text.charAt(j)) {
           diff++;
-          swapPoint = curr - 1;
+          i = j - 1;
         }
-        currCount++;
-        curr++;
+        count++;
+        j++;
       }
-      maxCount = Math.max(maxCount, currCount);
-      i = swapPoint + 1;
+      maxRepeatingLength = Math.max(maxRepeatingLength, count);
     }
-    return maxCount;
+    for (int i = text.length() - 1; i >= 0; i--) {
+      char c = text.charAt(i);
+      int count = 0;
+      int diff = 0;
+      int j = i;
+      while (j >= 0 && (c == text.charAt(j) || diff == 0) && count < frequency[c - 'a']) {
+        if (c != text.charAt(j)) {
+          diff++;
+          i = j + 1;
+        }
+        count++;
+        j--;
+      }
+      maxRepeatingLength = Math.max(maxRepeatingLength, count);
+    }
+    return maxRepeatingLength;
   }
 }

From 5c3a130a402bc975de45bd7767e4986ce1f6d58e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Jul 2022 18:08:28 -0700
Subject: [PATCH 1155/2175] Update Max Area of Island.java

---
 Medium/Max Area of Island.java | 57 ++++++++++++++--------------------
 1 file changed, 23 insertions(+), 34 deletions(-)

diff --git a/Medium/Max Area of Island.java b/Medium/Max Area of Island.java
index d1b4c461..b7fc94ba 100644
--- a/Medium/Max Area of Island.java	
+++ b/Medium/Max Area of Island.java	
@@ -1,45 +1,34 @@
 class Solution {
-  
-  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+  private final int[][] DIRS = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
   
   public int maxAreaOfIsland(int[][] grid) {
-    int rows = grid.length;
+    int area = 0;
+    int rows = grid.length; 
     int cols = grid[0].length;
-    int maxArea = 0;
+    boolean[][] visited = new boolean[rows][cols];
     for (int i = 0; i < rows; i++) {
       for (int j = 0; j < cols; j++) {
-        if (grid[i][j] != 0) {
-          grid[i][j] = 0;
-          int currentArea = getArea(grid, i, j);
-          maxArea = Math.max(maxArea, currentArea);
-        }
-      }
-    }
-    return maxArea;
-  }
-  
-  private int getArea(int[][] grid, int i, int j) {
-    int currentArea = 0;
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{i, j});
-    while (!queue.isEmpty()) {
-      int[] removed = queue.remove();
-      int currX = removed[0];
-      int currY = removed[1];
-      currentArea++;
-      for (int[] dir : DIRS) {
-        int newX = dir[0] + currX;
-        int newY = dir[1] + currY;
-        if (isValidCoordinate(grid, newX, newY) && grid[newX][newY] == 1) {
-          queue.add(new int[]{newX, newY});
-          grid[newX][newY] = 0;
+        if (!visited[i][j] && grid[i][j] == 1) {
+          Queue<int[]> queue = new LinkedList<>();
+          int currArea = 0;
+          queue.add(new int[]{i, j});
+          visited[i][j] = true;
+          while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            currArea++;
+            for (int[] dir : DIRS) {
+              int x = removed[0] + dir[0];
+              int y = removed[1] + dir[1];
+              if (x >= 0 && y >= 0 && x < rows && y < cols && !visited[x][y] && grid[x][y] == 1) {
+                queue.add(new int[]{x, y});
+                visited[x][y] = true;
+              }
+            }
+          }
+          area = Math.max(area, currArea);
         }
       }
     }
-    return currentArea;
-  }
-  
-  private boolean isValidCoordinate(int[][] grid, int i, int j) {
-    return i >= 0 && j >= 0 && i < grid.length && j < grid[0].length;
+    return area;
   }
 }

From 3d445a6db7d9a2d9610bdc001390cf8113e96bb5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Jul 2022 14:14:21 -0700
Subject: [PATCH 1156/2175] Create Out of Boundary Paths.java

---
 Medium/Out of Boundary Paths.java | 34 +++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Out of Boundary Paths.java

diff --git a/Medium/Out of Boundary Paths.java b/Medium/Out of Boundary Paths.java
new file mode 100644
index 00000000..7179a63c
--- /dev/null
+++ b/Medium/Out of Boundary Paths.java	
@@ -0,0 +1,34 @@
+class Solution {
+  private final int MODULUS = 1000000000 + 7;
+  
+  public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
+    int dp[][] = new int[m][n];
+    dp[startRow][startColumn] = 1;
+    int count = 0;
+    for (int currMove = 1; currMove <= maxMove; currMove++) {
+      int[][] temp = new int[m][n];
+      for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+          if (i == m - 1) {
+            count = (count + dp[i][j]) % MODULUS;
+          }
+          if (j == n - 1) {
+            count = (count + dp[i][j]) % MODULUS;
+          }
+          if (i == 0) {
+            count = (count + dp[i][j]) % MODULUS;
+          }
+          if (j == 0) {
+            count = (count + dp[i][j]) % MODULUS;
+          }
+          temp[i][j] = (
+              ((i > 0 ? dp[i - 1][j] : 0) + (i < m - 1 ? dp[i + 1][j] : 0)) % MODULUS +
+              ((j > 0 ? dp[i][j - 1] : 0) + (j < n - 1 ? dp[i][j + 1] : 0)) % MODULUS
+          ) % MODULUS;
+        }
+      }
+      dp = temp;
+    }
+    return count;
+  }
+}

From d2f9d242644692fbaaebdcdfca36dc69050f11db Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Jul 2022 16:08:30 -0700
Subject: [PATCH 1157/2175] Update Construct Binary Search Tree from Preorder
 Traversal.java

---
 ...y Search Tree from Preorder Traversal.java | 29 ++++++++++++-------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/Medium/Construct Binary Search Tree from Preorder Traversal.java b/Medium/Construct Binary Search Tree from Preorder Traversal.java
index 36407655..e2e044a8 100644
--- a/Medium/Construct Binary Search Tree from Preorder Traversal.java	
+++ b/Medium/Construct Binary Search Tree from Preorder Traversal.java	
@@ -15,18 +15,25 @@
  */
 class Solution {
   public TreeNode bstFromPreorder(int[] preorder) {
-    int[] idx = {0};
-    return formBST(preorder, Integer.MIN_VALUE, Integer.MAX_VALUE, idx);
-  }
-  
-  private TreeNode formBST(int[] preorder, int min, int max, int[] idx) {
-    if (idx[0] == preorder.length || preorder[idx[0]] < min || preorder[idx[0]] > max) {
+    if (preorder.length == 0) {
       return null;
     }
-    int val = preorder[idx[0]++];
-    TreeNode node = new TreeNode(val);
-    node.left = formBST(preorder, min, val, idx);
-    node.right = formBST(preorder, val, max, idx);
-    return node;
+    TreeNode root = new TreeNode(preorder[0]);
+    Stack<TreeNode> stack = new Stack<>();
+    stack.push(root);
+    for (int i = 1; i < preorder.length; i++) {
+      TreeNode node = stack.peek();
+      TreeNode child = new TreeNode(preorder[i]);
+      while (!stack.isEmpty() && stack.peek().val < child.val) {
+        node = stack.pop();
+      }
+      if (node.val < child.val) {
+        node.right = child;
+      } else {
+        node.left = child;
+      }
+      stack.push(child);
+    }
+    return root;
   }
 }

From 1b6513f2bc7a86c72f7f7a0040f61aa97f1d4e88 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Jul 2022 16:16:38 -0700
Subject: [PATCH 1158/2175] Update Minimum Moves to Convert String.java

---
 Easy/Minimum Moves to Convert String.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Easy/Minimum Moves to Convert String.java b/Easy/Minimum Moves to Convert String.java
index 61b7a169..cc4cb2b2 100644
--- a/Easy/Minimum Moves to Convert String.java	
+++ b/Easy/Minimum Moves to Convert String.java	
@@ -4,10 +4,11 @@ public int minimumMoves(String s) {
     int idx = 0;
     while (idx < s.length()) {
       if (s.charAt(idx) == 'X') {
-        idx += 2;
+        idx += 3;
         numOfMoves++;
+      } else {
+        idx++;
       }
-      idx++;
     }
     return numOfMoves;
   }

From 83b25f12df5d10b36e88fefcb10734133a91d497 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Jul 2022 22:29:04 -0700
Subject: [PATCH 1159/2175] Create Maximum Number of Pairs in Array.java

---
 Easy/Maximum Number of Pairs in Array.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Maximum Number of Pairs in Array.java

diff --git a/Easy/Maximum Number of Pairs in Array.java b/Easy/Maximum Number of Pairs in Array.java
new file mode 100644
index 00000000..38db03b0
--- /dev/null
+++ b/Easy/Maximum Number of Pairs in Array.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int[] numberOfPairs(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    int[] result = new int[2];
+    for (Integer key : map.keySet()) {
+      result[0] += map.get(key) / 2;
+      result[1] += map.get(key) % 2;
+    }
+    return result;
+  } 
+}

From e3841d689a8ce1d72859158f1db6e4f00badfe7c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Jul 2022 11:16:45 -0700
Subject: [PATCH 1160/2175] Create Max Sum of a Pair With Equal Sum of
 Digits.java

---
 ...um of a Pair With Equal Sum of Digits.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Max Sum of a Pair With Equal Sum of Digits.java

diff --git a/Medium/Max Sum of a Pair With Equal Sum of Digits.java b/Medium/Max Sum of a Pair With Equal Sum of Digits.java
new file mode 100644
index 00000000..597e0658
--- /dev/null
+++ b/Medium/Max Sum of a Pair With Equal Sum of Digits.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int maximumSum(int[] nums) {
+    int maxSum = -1;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      int digitSum = getDigitSum(num);
+      if (map.containsKey(digitSum)) {
+        maxSum = Math.max(maxSum, map.get(digitSum) + num);
+        map.put(digitSum, Math.max(map.get(digitSum), num));
+      } else {
+        map.put(digitSum, num);
+      }
+    }
+    return maxSum;
+  }
+  
+  private int getDigitSum(int num) {
+    int sum = 0;
+    while (num > 0) {
+      sum += num % 10;
+      num /= 10;
+    }
+    return sum;
+  }
+}

From e21bda4327ecb01347fa022e7158691ed09609c7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Jul 2022 11:18:20 -0700
Subject: [PATCH 1161/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c09eb6d8..ddb9b55e 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 1000+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1100+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count

From e7800d4f3197e4a3ba8f58f7d36d205325832074 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Jul 2022 16:15:54 -0700
Subject: [PATCH 1162/2175] Create K Inverse Pairs Array.java

---
 Hard/K Inverse Pairs Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Hard/K Inverse Pairs Array.java

diff --git a/Hard/K Inverse Pairs Array.java b/Hard/K Inverse Pairs Array.java
new file mode 100644
index 00000000..0b6e0d8f
--- /dev/null
+++ b/Hard/K Inverse Pairs Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int kInversePairs(int n, int k) {
+    int[][] dp = new int[n + 1][k + 1];
+    int mod = 1000000007;
+    for (int i = 1; i <= n; i++) {
+      for (int j = 0; j <= k; j++) {
+        if (j == 0) {
+          dp[i][j] = 1;
+        } else {
+          int curr = (dp[i - 1][j] + mod - ((j - i) >= 0 ? dp[i - 1][j - i] : 0)) % mod;
+          dp[i][j] = (dp[i][j - 1] + curr) % mod;
+        }
+      }
+    }
+    return ((dp[n][k] + mod - (k > 0 ? dp[n][k - 1] : 0)) % mod);
+  }
+}

From e46df51a30ff95a6c5cb033956ed89be7081536e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 18 Jul 2022 08:59:15 -0700
Subject: [PATCH 1163/2175] Update Number of Submatrices That Sum to
 Target.java

---
 ...ber of Submatrices That Sum to Target.java | 47 +++++++++----------
 1 file changed, 22 insertions(+), 25 deletions(-)

diff --git a/Hard/Number of Submatrices That Sum to Target.java b/Hard/Number of Submatrices That Sum to Target.java
index edd19f0d..d8f9dfc5 100644
--- a/Hard/Number of Submatrices That Sum to Target.java	
+++ b/Hard/Number of Submatrices That Sum to Target.java	
@@ -1,29 +1,26 @@
 class Solution {
-    public int numSubmatrixSumTarget(int[][] matrix, int target) {
-        int rows = matrix.length;
-        int cols = matrix[0].length;
-        int res = 0;
-        
-        for (int i = 0; i < rows; i++) {
-            for (int j = 1; j < cols; j++) {
-                matrix[i][j] += matrix[i][j - 1];
-            }
-        }
-        
-        for (int i = 0; i < cols; i++) {
-            for (int j = i; j < cols; j++) {
-                Map<Integer, Integer> map = new HashMap<>();
-                map.put(0, 1);
-                int sum = 0;
-                for (int k = 0; k < rows; k++) {
-                    sum += matrix[k][j] - (i > 0 ? matrix[k][i - 1] : 0);
-                    res += map.getOrDefault(sum - target, 0);
-                    
-                    map.put(sum, map.getOrDefault(sum, 0) + 1);
-                }
-            }
+  public int numSubmatrixSumTarget(int[][] matrix, int target) {
+    int rows = matrix.length;
+    int cols = matrix[0].length;
+    int[][] prefixSum = new int[rows + 1][cols + 1];
+    for (int i = 1; i <= rows; i++) {
+      for (int j = 1; j <= cols; j++) {
+        prefixSum[i][j] = prefixSum[i - 1][j] + prefixSum[i][j - 1] - prefixSum[i - 1][j - 1] + matrix[i - 1][j - 1];
+      }
+    }
+    int count = 0;
+    int currSum = 0;
+    for (int i = 1; i <= rows; i++) {
+      for (int j = i; j <= rows; j++) {
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(0, 1);
+        for (int k = 1; k <= cols; k++) {
+          currSum = prefixSum[j][k] - prefixSum[i - 1][k];
+          count += map.getOrDefault(currSum - target, 0);
+          map.put(currSum, map.getOrDefault(currSum, 0) + 1);
         }
-        
-        return res;
+      }
     }
+    return count;
+  }
 }

From 1c32af05e75e352614a848c68508667220c4851f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 19 Jul 2022 14:04:50 -0700
Subject: [PATCH 1164/2175] Update Find Smallest Letter Greater Than
 Target.java

---
 ...ind Smallest Letter Greater Than Target.java | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/Easy/Find Smallest Letter Greater Than Target.java b/Easy/Find Smallest Letter Greater Than Target.java
index 161760cb..62e6cf03 100644
--- a/Easy/Find Smallest Letter Greater Than Target.java	
+++ b/Easy/Find Smallest Letter Greater Than Target.java	
@@ -2,23 +2,16 @@ class Solution {
   public char nextGreatestLetter(char[] letters, char target) {
     int start = 0;
     int end = letters.length - 1;
-    // ASCII char greater than 'z'
-    char smallestChar = '{';
+    int minIdx = Integer.MAX_VALUE;
     while (start <= end) {
       int mid = (start + end) / 2;
-      if (letters[mid] - target > 0) {
-        if (smallestChar - letters[mid] > 0) {
-          smallestChar = letters[mid];
-        }
+      if (letters[mid] > target) {
+        minIdx = mid;
         end = mid - 1;
-      }
-      else if (letters[mid] - target == 0) {
-        start = mid + 1;
-      }
-      else {
+      } else {
         start = mid + 1;
       }
     }
-    return smallestChar == '{' ? letters[0] : smallestChar;
+    return minIdx == Integer.MAX_VALUE ? letters[0] : letters[minIdx];
   }
 }

From 1a9b07cc5a01348888fb76ad2f2efbab747ccf83 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 19 Jul 2022 18:15:50 -0700
Subject: [PATCH 1165/2175] Update Number of Matching Subsequences.java

---
 Medium/Number of Matching Subsequences.java | 33 ++++++++-------------
 1 file changed, 12 insertions(+), 21 deletions(-)

diff --git a/Medium/Number of Matching Subsequences.java b/Medium/Number of Matching Subsequences.java
index aa974e8f..355527ee 100644
--- a/Medium/Number of Matching Subsequences.java	
+++ b/Medium/Number of Matching Subsequences.java	
@@ -1,33 +1,24 @@
 class Solution {
   public int numMatchingSubseq(String s, String[] words) {
-    Map<Character, List<Pair>> map = new HashMap<>();
+    Map<Character, List<int[]>> map = new HashMap<>();
     for (int i = 0; i < words.length; i++) {
-      map.computeIfAbsent(words[i].charAt(0), k -> new ArrayList<>()).add(new Pair(0, i));
+      map.computeIfAbsent(words[i].charAt(0), k -> new ArrayList<>()).add(new int[]{0, i});
     }
-    int counter = 0;
+    int result = 0;
     for (char c : s.toCharArray()) {
-      List<Pair> existingPairs = map.getOrDefault(c, new ArrayList<>());
+      List<int[]> values = map.getOrDefault(c, new ArrayList<>());
       map.put(c, new ArrayList<>());
-      for (Pair pair : existingPairs) {
-        int currIdx = pair.currIdx;
-        if (currIdx + 1 == words[pair.wordIdx].length()) {
-          counter++;
+      for (int[] val : values) {
+        int stringIdx = val[0];
+        int wordIdx = val[1];
+        if (stringIdx + 1 == words[wordIdx].length()) {
+          result++;
         } else {
-          map.computeIfAbsent(words[pair.wordIdx].charAt(currIdx + 1), k -> new ArrayList<>())
-              .add(new Pair(currIdx + 1, pair.wordIdx));
+          char nextChar = words[wordIdx].charAt(stringIdx + 1);
+          map.computeIfAbsent(nextChar, k -> new ArrayList<>()).add(new int[]{stringIdx + 1, wordIdx});
         }
       }
     }
-    return counter;
-  }
-  
-  private static class Pair {
-    int currIdx;
-    int wordIdx;
-
-    public Pair(int currIdx, int wordIdx) {
-      this.currIdx = currIdx;
-      this.wordIdx = wordIdx;
-    }
+    return result;
   }
 }

From 38ea72c956f207252fdce6ca56b161ebfd1fd0e6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Jul 2022 08:58:49 -0700
Subject: [PATCH 1166/2175] Update Flatten Nested List Iterator.java

---
 Medium/Flatten Nested List Iterator.java | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Medium/Flatten Nested List Iterator.java b/Medium/Flatten Nested List Iterator.java
index 30006429..5081ee2e 100644
--- a/Medium/Flatten Nested List Iterator.java	
+++ b/Medium/Flatten Nested List Iterator.java	
@@ -20,30 +20,27 @@ public class NestedIterator implements Iterator<Integer> {
   private Stack<NestedInteger> stack;
   
   public NestedIterator(List<NestedInteger> nestedList) {
-    stack = new Stack<>();
+    this.stack = new Stack<>();
     for (int i = nestedList.size() - 1; i >= 0; i--) {
-      stack.push(nestedList.get(i));
+      this.stack.push(nestedList.get(i));
     }
   }
 
   @Override
   public Integer next() {
-    return stack.pop().getInteger();
+    int value = this.stack.pop().getInteger();
+    return value;
   }
-  
+
   @Override
   public boolean hasNext() {
-    while (!stack.isEmpty() && !stack.peek().isInteger()) {
-      NestedInteger popped = stack.pop();
-      if (popped == null) {
-        continue;
-      }
-      List<NestedInteger> list = popped.getList();
-      for (int i = list.size() - 1; i >= 0; i--) {
-        stack.push(list.get(i));
+    while (!this.stack.isEmpty() && !this.stack.peek().isInteger()) {
+      List<NestedInteger> ni = this.stack.pop().getList();
+      for (int i = ni.size() - 1; i >= 0; i--) {
+        this.stack.push(ni.get(i));
       }
     }
-    return !stack.isEmpty();
+    return !this.stack.isEmpty();
   }
 }
 

From f35ddf303b3e895deab3c650cae12848c0f8d451 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Jul 2022 10:15:54 -0700
Subject: [PATCH 1167/2175] Update Mini Parser.java

---
 Medium/Mini Parser.java | 38 +++++++++++++++++---------------------
 1 file changed, 17 insertions(+), 21 deletions(-)

diff --git a/Medium/Mini Parser.java b/Medium/Mini Parser.java
index a900b446..6fba4058 100644
--- a/Medium/Mini Parser.java	
+++ b/Medium/Mini Parser.java	
@@ -22,49 +22,45 @@
  *     public void add(NestedInteger ni);
  *
  *     // @return the nested list that this NestedInteger holds, if it holds a nested list
- *     // Return null if this NestedInteger holds a single integer
+ *     // Return empty list if this NestedInteger holds a single integer
  *     public List<NestedInteger> getList();
  * }
  */
 class Solution {
   public NestedInteger deserialize(String s) {
-    if (s == null || s.length() == 0) {
+    if (s.isEmpty()) {
       return null;
     }
     if (s.charAt(0) != '[') {
-      return new NestedInteger(Integer.valueOf(s));
+      return new NestedInteger(Integer.parseInt(s));
     }
     Stack<NestedInteger> stack = new Stack<>();
     NestedInteger curr = null;
-    int start = 0;
-    int n = s.length();
-    for (int end = 0; end < n; end++) {
-      char c = s.charAt(end);
-      if (c == '[') {
+    int leftIdx = 0;
+    for (int rightIdx = 0; rightIdx < s.length(); rightIdx++) {
+      if (s.charAt(rightIdx) == '[') {
         if (curr != null) {
           stack.push(curr);
         }
         curr = new NestedInteger();
-        start = end + 1;
-      }
-      else if (c == ']') {
-        String num = s.substring(start, end);
-        if (!num.isEmpty()) {
-          curr.add(new NestedInteger(Integer.valueOf(num)));
+        leftIdx = rightIdx + 1;
+      } else if (s.charAt(rightIdx) == ']') {
+        String number = s.substring(leftIdx, rightIdx);
+        if (!number.isEmpty()) {
+          curr.add(new NestedInteger(Integer.parseInt(number)));
         }
         if (!stack.isEmpty()) {
           NestedInteger popped = stack.pop();
           popped.add(curr);
           curr = popped;
         }
-        start = end + 1;
-      }
-      else if (c == ',') {
-        if (s.charAt(end - 1) != ']') {
-          String num = s.substring(start, end);
-          curr.add(new NestedInteger(Integer.valueOf(num)));
+        leftIdx = rightIdx + 1;
+      } else if (s.charAt(rightIdx) == ',') {
+        if (s.charAt(rightIdx - 1) != ']') {
+          String number = s.substring(leftIdx, rightIdx);
+          curr.add(new NestedInteger(Integer.parseInt(number)));
         }
-        start = end + 1;
+        leftIdx = rightIdx + 1;
       }
     }
     return curr;

From f805e1b0a189b78cb1dd87e8072ffc08e4d753b2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Jul 2022 12:26:17 -0700
Subject: [PATCH 1168/2175] Update Find All the Lonely Nodes.java

---
 Easy/Find All the Lonely Nodes.java | 33 +++++++++++++++++------------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/Easy/Find All the Lonely Nodes.java b/Easy/Find All the Lonely Nodes.java
index 369cf65f..1cae56ab 100644
--- a/Easy/Find All the Lonely Nodes.java	
+++ b/Easy/Find All the Lonely Nodes.java	
@@ -15,19 +15,26 @@
  */
 class Solution {
   public List<Integer> getLonelyNodes(TreeNode root) {
-    List<Integer> list = new ArrayList<>();
-    helper(root, null, list);
-    return list;
-  }
-  
-  private void helper(TreeNode node, TreeNode parent, List<Integer> list) {
-    if (node == null) {
-      return;
-    }
-    if (parent != null && ((parent.left != null && parent.right == null) || (parent.right != null && parent.left == null))) {
-      list.add(node.val);
+    List<Integer> lonelyNodes = new ArrayList<>();
+    Queue<TreeNode[]> queue = new LinkedList<>();
+    queue.add(new TreeNode[]{root, null});
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeNode[] removed = queue.remove();
+        TreeNode node = removed[0];
+        TreeNode parent = removed[1];
+        if (parent != null && ((parent.left == node && parent.right == null) || (parent.right == node && parent.left == null))) {
+          lonelyNodes.add(node.val);
+        }
+        if (node.left != null) {
+          queue.add(new TreeNode[]{node.left, node});
+        }
+        if (node.right != null) {
+          queue.add(new TreeNode[]{node.right, node});
+        }
+      }
     }
-    helper(node.left, node, list);
-    helper(node.right, node, list);
+    return lonelyNodes;
   }
 }

From a0b309dae7b5c577754efb5da835e13e7e2d3d20 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Jul 2022 12:26:55 -0700
Subject: [PATCH 1169/2175] Update Design a Stack With Increment Operation.java

---
 ...sign a Stack With Increment Operation.java | 30 ++++++++++---------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/Medium/Design a Stack With Increment Operation.java b/Medium/Design a Stack With Increment Operation.java
index 34f80a99..9164401b 100644
--- a/Medium/Design a Stack With Increment Operation.java	
+++ b/Medium/Design a Stack With Increment Operation.java	
@@ -1,36 +1,38 @@
 class CustomStack {
-  Stack<Integer> stack;
-  int maxSize;
-  int[] increment;
+  
+  private Stack<Integer> stack;
+  private int[] incrementArray;
+  private int maxSize;
+  
   public CustomStack(int maxSize) {
+    this.stack = new Stack<>();
+    this.incrementArray = new int[maxSize];
     this.maxSize = maxSize;
-    stack = new Stack<>();
-    increment = new int[maxSize];
   }
 
   public void push(int x) {
-    if (stack.size() < maxSize) {
-      stack.push(x);
+    if (this.stack.size() < this.maxSize) {
+      this.stack.push(x);
     }
   }
 
   public int pop() {
-    int idx = stack.size() - 1;
+    int idx = this.stack.size() - 1;
     if (idx < 0) {
       return -1;
     }
     if (idx > 0) {
-      increment[idx - 1] += increment[idx];
+      this.incrementArray[idx - 1] += this.incrementArray[idx];
     }
-    int ans = stack.pop() + increment[idx];
-    increment[idx] = 0;
-    return ans;
+    int result = this.stack.pop() + this.incrementArray[idx];
+    this.incrementArray[idx] = 0;
+    return result;
   }
 
   public void increment(int k, int val) {
-    int idx = Math.min(k, stack.size()) - 1;
+    int idx = Math.min(k, this.stack.size()) - 1;
     if (idx >= 0) {
-      increment[idx] += val;
+      this.incrementArray[idx] += val;
     }
   }
 }

From 799da785c07e5f89cbdb568e21628f6ed960d8b5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Jul 2022 13:54:24 -0700
Subject: [PATCH 1170/2175] Update Majority Element.java

---
 Easy/Majority Element.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Easy/Majority Element.java b/Easy/Majority Element.java
index 3c2b580c..0fc7be1d 100644
--- a/Easy/Majority Element.java	
+++ b/Easy/Majority Element.java	
@@ -1,13 +1,13 @@
 class Solution {
   public int majorityElement(int[] nums) {
+    int majorityElement = nums[0];
     int count = 0;
-    Integer candidate = null;
     for (int num : nums) {
       if (count == 0) {
-        candidate = num;
+        majorityElement = num;
       }
-      count += num == candidate ? 1 : -1;
+      count += num == majorityElement ? 1 : -1;
     }
-    return candidate;
-  }
+    return majorityElement;
+  }   
 }

From de2ca0b4f926a64501943c6647ac58f7b806a4d6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Jul 2022 13:54:42 -0700
Subject: [PATCH 1171/2175] Update Find First and Last Position of Element in
 Sorted Array.java

---
 ...t Position of Element in Sorted Array.java | 42 +++++++------------
 1 file changed, 14 insertions(+), 28 deletions(-)

diff --git a/Medium/Find First and Last Position of Element in Sorted Array.java b/Medium/Find First and Last Position of Element in Sorted Array.java
index 89775bdf..a61bd0dc 100644
--- a/Medium/Find First and Last Position of Element in Sorted Array.java	
+++ b/Medium/Find First and Last Position of Element in Sorted Array.java	
@@ -1,39 +1,25 @@
 class Solution {
   public int[] searchRange(int[] nums, int target) {
-    return new int[]{binarySearchForMinIdx(nums, target), binarySearchForMaxIdx(nums, target)};
+    return new int[]{binarySearchHelper(nums, target, -1), binarySearchHelper(nums, target, 1)};
   }
   
-  private int binarySearchForMinIdx(int[] nums, int target) {
-    int leftIdx = 0;
-    int rightIdx = nums.length - 1;
+  private int binarySearchHelper(int[] nums, int target, int direction) {
     int idx = -1;
-    while (leftIdx <= rightIdx) {
-      int mid = (leftIdx + rightIdx) / 2;
+    int start = 0;
+    int end = nums.length - 1;
+    while (start <= end) {
+      int mid = (start + end) / 2;
       if (nums[mid] == target) {
-        idx = mid;
-        rightIdx = mid - 1;
+        idx = idx == -1 ? mid : (direction == -1 ? Math.min(mid, idx) : Math.max(mid, idx));
+        if (direction == -1) {
+          end = mid - 1;
+        } else {
+          start = mid + 1;
+        }
       } else if (nums[mid] > target) {
-        rightIdx = mid - 1;
+        end = mid - 1;
       } else {
-        leftIdx = mid + 1;
-      }
-    }
-    return idx;
-  }
-  
-  private int binarySearchForMaxIdx(int[] nums, int target) {
-    int leftIdx = 0;
-    int rightIdx = nums.length - 1;
-    int idx = -1;
-    while (leftIdx <= rightIdx) {
-      int mid = (leftIdx + rightIdx) / 2;
-      if (nums[mid] == target) {
-        idx = mid;
-        leftIdx = mid + 1;
-      } else if (nums[mid] > target) {
-        rightIdx = mid - 1;
-      } else {
-        leftIdx = mid + 1;
+        start = mid + 1;
       }
     }
     return idx;

From 7c77a36700e85a524187698ccba6fafb486a4981 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Jul 2022 17:35:33 -0700
Subject: [PATCH 1172/2175] Update Reverse Linked List II.java

---
 Medium/Reverse Linked List II.java | 68 +++++++++++++++++-------------
 1 file changed, 39 insertions(+), 29 deletions(-)

diff --git a/Medium/Reverse Linked List II.java b/Medium/Reverse Linked List II.java
index ca17dc02..53edc4e4 100644
--- a/Medium/Reverse Linked List II.java	
+++ b/Medium/Reverse Linked List II.java	
@@ -3,37 +3,47 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode reverseBetween(ListNode head, int m, int n) {
-        if (head == null || m == n || m > n) {
-            return head;
-        }
-        
-        ListNode dummy = new ListNode(0);
-        dummy.next = head;
-        ListNode pre = dummy;
-        ListNode curr = dummy.next;
-        
-        for (int i = 1; i < m; i++) {
-            pre = curr;
-            curr = curr.next;
-        }
-        
-        ListNode node = pre;
-        
-        for (int i = m; i <= n; i++) {
-            ListNode tmp = curr.next;
-            curr.next = pre;
-            pre = curr;
-            curr = tmp;
-        }
-        
-        node.next.next = curr;
-        node.next = pre;
-        
-        return dummy.next;
+  public ListNode reverseBetween(ListNode head, int left, int right) {
+    ListNode prev = null;
+    ListNode start = head;
+    for (int i = 1; i < left; i++) {
+      prev = start;
+      start = start.next;
     }
+    ListNode end = start;
+    for (int i = left; i < right; i++) {
+      end = end.next;
+    }
+    ListNode nextToEnd = end.next;
+    end.next = null;
+    ListNode reverseStart = reverse(start);
+    if (prev != null) {
+      prev.next = reverseStart;
+    }
+    ListNode curr = reverseStart;
+    while (curr.next != null) {
+      curr = curr.next;
+    }
+    curr.next = nextToEnd;
+    return prev == null ? reverseStart : head;
+  }
+  
+  private ListNode reverse(ListNode node) {
+    ListNode prev = null;
+    ListNode next = null;
+    ListNode curr = node;
+    while (curr != null) {
+      next = curr.next;
+      curr.next = prev;
+      prev = curr;
+      curr = next;
+    }
+    return prev;
+  }
 }

From 4509f047ab7c4fdf2d60a0560179a2a2e306f330 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 21 Jul 2022 18:56:42 -0700
Subject: [PATCH 1173/2175] Update Partition List.java

---
 Medium/Partition List.java | 59 ++++++++++++++++++++++----------------
 1 file changed, 34 insertions(+), 25 deletions(-)

diff --git a/Medium/Partition List.java b/Medium/Partition List.java
index 400a58f4..bb1f9dcf 100644
--- a/Medium/Partition List.java	
+++ b/Medium/Partition List.java	
@@ -3,35 +3,44 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public ListNode partition(ListNode head, int x) {
-        Queue<Integer> small = new LinkedList<>();
-        Queue<Integer> bigOrEqual = new LinkedList<>();
-        ListNode curr = head;
-        while (curr != null){
-            if (curr.val < x) {
-                small.add(curr.val);
-            }
-            else {
-                bigOrEqual.add(curr.val);
-            }
-            curr = curr.next;
+  public ListNode partition(ListNode head, int x) {
+    ListNode lessThanHead = null;
+    ListNode lessThan = null;
+    ListNode greaterThan = null;
+    ListNode greaterThanHead = null;
+    while (head != null) {
+      ListNode nextNode = head.next;
+      if (head.val < x) {
+        if (lessThan == null) {
+          lessThan = head;
+          lessThanHead = lessThan;
+        } else {
+          lessThan.next = head;
+          lessThan = lessThan.next;
         }
-        
-        curr = head;
-        while (curr != null) {
-            if (!small.isEmpty()) {
-                curr.val = small.remove();
-            }
-            else {
-                curr.val = bigOrEqual.remove();
-            }
-            curr = curr.next;
+        lessThan.next = null;
+      } else {
+        if (greaterThan == null) {
+          greaterThan = head;
+          greaterThanHead = greaterThan;
+        } else {
+          greaterThan.next = head;
+          greaterThan = greaterThan.next;
         }
-        
-        return head;
+        greaterThan.next = null;
+      }
+      head = nextNode;
     }
+    if (lessThanHead == null || greaterThanHead == null) {
+      return lessThan == null ? greaterThanHead : lessThanHead;
+    }
+    lessThan.next = greaterThanHead;
+    return lessThanHead;
+  }
 }

From c66c9575817a786aa7082fab0afb1ec6f05fd5f4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Jul 2022 09:48:08 -0700
Subject: [PATCH 1174/2175] Create Remove All Ones With Row and Column Flips
 II.java

---
 ...All Ones With Row and Column Flips II.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Remove All Ones With Row and Column Flips II.java

diff --git a/Medium/Remove All Ones With Row and Column Flips II.java b/Medium/Remove All Ones With Row and Column Flips II.java
new file mode 100644
index 00000000..aeeeab2f
--- /dev/null
+++ b/Medium/Remove All Ones With Row and Column Flips II.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int removeOnes(int[][] grid) {
+    return removeOnesHelper(grid, 0, 0);
+  }
+  
+  private int removeOnesHelper(int[][] grid, int x, int y) {
+    int rows = grid.length;
+    int cols = grid[0].length;
+    int result = Integer.MAX_VALUE;
+    int ones = 0; 
+    for (int i = 0; i < rows; i++) {
+      if ((x & (1 << i)) == 0) {
+        for (int j = 0; j < cols; j++) {
+          if ((y & (1 << j)) == 0 && grid[i][j] == 1) {
+            ones++;
+            result = Math.min(result, 1 + removeOnesHelper(grid, x + (1 << i), y + (1 << j)));
+          }
+        }
+      }
+    }
+    return ones == 0 ? 0 : result;
+  }
+}

From 66408f0a279172e4d33768c1df8d0b14dffbc3d6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Jul 2022 10:01:06 -0700
Subject: [PATCH 1175/2175] Update Encode and Decode Strings.java

---
 Medium/Encode and Decode Strings.java | 32 ++++++++++++++++++---------
 1 file changed, 21 insertions(+), 11 deletions(-)

diff --git a/Medium/Encode and Decode Strings.java b/Medium/Encode and Decode Strings.java
index ec923b8f..c39d5b6a 100644
--- a/Medium/Encode and Decode Strings.java	
+++ b/Medium/Encode and Decode Strings.java	
@@ -3,8 +3,8 @@ public class Codec {
   // Encodes a list of strings to a single string.
   public String encode(List<String> strs) {
     StringBuilder sb = new StringBuilder();
-    for (String str : strs) {
-      sb.append(lengthEncode(str)).append(str);
+    for (String s : strs) {
+      sb.append(lengthEncoding(s)).append(s);
     }
     return sb.toString();
   }
@@ -12,24 +12,34 @@ public String encode(List<String> strs) {
   // Decodes a single string to a list of strings.
   public List<String> decode(String s) {
     int idx = 0;
+    List<String> result = new ArrayList<>();
     int n = s.length();
-    List<String> list = new ArrayList<>();
     while (idx < n) {
-      int length = Integer.parseInt(s.substring(idx, idx + 10));
-      idx += 10;
-      list.add(s.substring(idx, idx + length));
-      idx += length;
+      int currStringLength = lengthDecoding(s.substring(idx, idx + 4));
+      idx += 4;
+      result.add(s.substring(idx, idx + currStringLength));
+      idx += currStringLength;
     }
-    return list;
+    return result;
   }
   
-  private String lengthEncode(String s) {
+  private String lengthEncoding(String s) {
     int n = s.length();
-    return String.join("", Collections.nCopies(10 - String.valueOf(n).length(), "0")) + String.valueOf(n);
+    char[] bytes = new char[4];
+    for(int i = 3; i >= 0; i--) {
+      bytes[3 - i] = (char) (n >> (i * 8) & 0xff);
+    }
+    return new String(bytes);
+  }
+  
+  private int lengthDecoding(String bytesStr) {
+    int result = 0;
+    for(char b : bytesStr.toCharArray())
+      result = (result << 8) + (int)b;
+    return result;
   }
 }
 
 // Your Codec object will be instantiated and called as such:
 // Codec codec = new Codec();
 // codec.decode(codec.encode(strs));
-

From d85b3d385a597d2b7fb107ba6202dd0dc2bc54b1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Jul 2022 12:04:52 -0700
Subject: [PATCH 1176/2175] Update Integer To Roman.java

---
 Medium/Integer To Roman.java | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/Medium/Integer To Roman.java b/Medium/Integer To Roman.java
index cbc5aead..33de2ba3 100644
--- a/Medium/Integer To Roman.java	
+++ b/Medium/Integer To Roman.java	
@@ -1,14 +1,19 @@
 class Solution {
+  
+  private static final int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+  private static final String[] symbols = {
+    "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+  
   public String intToRoman(int num) {
-    int[] divisor = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
-    String[] numerals = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
     StringBuilder sb = new StringBuilder();
-    for (int i = 0; i < divisor.length; i++) {
-      int fact = num / divisor[i];
-      while (fact-- > 0) {
-        sb.append(numerals[i]);
+    for (int i = 0; i < values.length && num > 0; i++) {
+      int factor = num / values[i];
+      num %= values[i];
+      if (factor > 0) {
+        for (int j = 1; j <= factor; j++) {
+          sb.append(symbols[i]);
+        }
       }
-      num = num % divisor[i];
     }
     return sb.toString();
   }

From 8ed4e07a2cfd9df150bbbbd1a1c76c9e3930ba18 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Jul 2022 13:00:20 -0700
Subject: [PATCH 1177/2175] Update and rename Hard/Insert Interval.java to
 Medium/Insert Interval.java

---
 Hard/Insert Interval.java   | 49 -------------------------------------
 Medium/Insert Interval.java | 32 ++++++++++++++++++++++++
 2 files changed, 32 insertions(+), 49 deletions(-)
 delete mode 100644 Hard/Insert Interval.java
 create mode 100644 Medium/Insert Interval.java

diff --git a/Hard/Insert Interval.java b/Hard/Insert Interval.java
deleted file mode 100644
index a4b6f9cc..00000000
--- a/Hard/Insert Interval.java	
+++ /dev/null
@@ -1,49 +0,0 @@
-class Solution {
-  public int[][] insert(int[][] intervals, int[] newInterval) {
-    List<int[]> list = new ArrayList<>();
-    boolean merged = false;
-    int idx = 0;
-    int n = intervals.length;
-    while (idx < n) {
-      if (merged) {
-        list.add(intervals[idx++]);
-        continue;
-      }
-      if (isOverlap(intervals[idx], newInterval)) {
-        int start = Math.min(intervals[idx][0], newInterval[0]);
-        int currEnd = Math.max(intervals[idx][1], newInterval[1]);
-        idx++;
-        while (idx < n && intervals[idx][0] <= currEnd) {
-          currEnd = Math.max(currEnd, intervals[idx][1]);
-          idx++;
-        }
-        list.add(new int[]{start, currEnd});
-        merged = true;
-      }
-      else if (intervals[idx][0] > newInterval[1]) {
-        list.add(newInterval);
-        list.add(intervals[idx++]);
-        merged = true;
-      }
-      else {
-        list.add(intervals[idx++]);
-      }
-    }
-    if (!merged) {
-      list.add(newInterval);
-    }
-    int[][] ans = new int[list.size()][2];
-    for (int i = 0; i < list.size(); i++) {
-      ans[i] = list.get(i);
-    }
-    return ans;
-  }
-  
-  private boolean isOverlap(int[] i1, int[] i2) {
-    return (
-      (i2[0] <= i1[1] && i2[0] >= i1[0]) ||
-      (i2[1] >= i1[0] && i2[0] <= i1[0]) ||
-      (i2[0] >= i1[0] && i2[1] <= i1[1])
-    );
-  }
-}
diff --git a/Medium/Insert Interval.java b/Medium/Insert Interval.java
new file mode 100644
index 00000000..a263b710
--- /dev/null
+++ b/Medium/Insert Interval.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public int[][] insert(int[][] intervals, int[] newInterval) {
+    List<int[]> result = new ArrayList<>();
+    int idx = 0;
+    int newStart = newInterval[0];
+    int newEnd = newInterval[1];
+    while (idx < intervals.length && newStart > intervals[idx][0]) {
+      result.add(intervals[idx++]);
+    }
+    int[] currInterval = new int[2];
+    if (result.isEmpty() || result.get(result.size() - 1)[1] < newStart) {
+      result.add(newInterval);
+    } else {
+      currInterval = result.remove(result.size() - 1);
+      currInterval[1] = Math.max(currInterval[1], newEnd);
+      result.add(currInterval);
+    }
+    while (idx < intervals.length) {
+      currInterval = intervals[idx++];
+      int start = currInterval[0];
+      int end = currInterval[1];
+      if (result.get(result.size() - 1)[1] < start) {
+        result.add(currInterval);
+      } else {
+        currInterval = result.remove(result.size() - 1);
+        currInterval[1] = Math.max(currInterval[1], end);
+        result.add(currInterval);
+      }
+    }
+    return result.toArray(new int[result.size()][2]);
+  }
+}

From 51d5694f8a84ff70896576253af3645756d756eb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Jul 2022 07:55:23 -0700
Subject: [PATCH 1178/2175] Create Count of Smaller Numbers After Self.java

---
 Hard/Count of Smaller Numbers After Self.java | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 Hard/Count of Smaller Numbers After Self.java

diff --git a/Hard/Count of Smaller Numbers After Self.java b/Hard/Count of Smaller Numbers After Self.java
new file mode 100644
index 00000000..30f10d48
--- /dev/null
+++ b/Hard/Count of Smaller Numbers After Self.java	
@@ -0,0 +1,50 @@
+class Solution {
+  public List<Integer> countSmaller(int[] nums) {
+    int n = nums.length;
+    int[] result = new int[n];
+    int[] indices = new int[n];
+    for (int i = 0; i < n; i++) {
+      indices[i] = i;
+    }
+    mergesort(indices, 0, n, result, nums);
+    return Arrays.stream(result).boxed().collect(Collectors.toList());
+  }
+  
+  private void mergesort(int[] indices, int left, int right, int[] result, int[] nums) {
+    if (right - left <= 1) {
+      return;
+    }
+    int mid = (left + right) / 2;
+    mergesort(indices, left, mid, result, nums);
+    mergesort(indices, mid, right, result, nums);
+    merge(indices, left, right, mid, result, nums);
+  }
+  
+  private void merge(int[] indices, int left, int right, int mid, int[] result, int[] nums) {
+    int i = left;
+    int j = mid;
+    List<Integer> temp = new ArrayList<>();
+    while (i < mid && j < right) {
+      if (nums[indices[i]] <= nums[indices[j]]) {
+        result[indices[i]] += j - mid;
+        temp.add(indices[i]);
+        i++;
+      } else {
+        temp.add(indices[j]);
+        j++;
+      }
+    }
+    while (i < mid) {
+      result[indices[i]] += j - mid;
+      temp.add(indices[i]);
+      i++;
+    }
+    while (j < right) {
+      temp.add(indices[j]);
+      j++;
+    }
+    for (int k = left; k < right; k++) {
+      indices[k] = temp.get(k - left);
+    }
+  }
+}

From ae4c776ddd7c31ef1060f41a6a792b5dfbcad9fa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Jul 2022 14:07:26 -0700
Subject: [PATCH 1179/2175] Create Best Poker Hand.java

---
 Easy/Best Poker Hand.java | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Easy/Best Poker Hand.java

diff --git a/Easy/Best Poker Hand.java b/Easy/Best Poker Hand.java
new file mode 100644
index 00000000..3a648cc1
--- /dev/null
+++ b/Easy/Best Poker Hand.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public String bestHand(int[] ranks, char[] suits) {
+    char suitCard = '-';
+    for (int i = 0; i < suits.length; i++) {
+      if (suitCard != '-' && suitCard != suits[i]) {
+        break;
+      }
+      if (suitCard == '-') {
+        suitCard = suits[i];
+      }
+      if (i == suits.length - 1) {
+        return "Flush";
+      }
+    }
+    Map<Integer, Integer> frequencyMap = new HashMap<>();
+    boolean pairFound = false;
+    for (int rank : ranks) {
+      frequencyMap.put(rank, frequencyMap.getOrDefault(rank, 0) + 1);
+      if (frequencyMap.get(rank) == 3) {
+        return "Three of a Kind";
+      }
+      if (frequencyMap.get(rank) == 2) {
+        pairFound = true;
+      }
+    }
+    return pairFound ? "Pair" : "High Card";
+  }
+}

From daa0f1a1f37481dd234d251ffa7378f7d5aa12a2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Jul 2022 14:17:16 -0700
Subject: [PATCH 1180/2175] Create Number of Zero-Filled Subarrays.java

---
 Medium/Number of Zero-Filled Subarrays.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Number of Zero-Filled Subarrays.java

diff --git a/Medium/Number of Zero-Filled Subarrays.java b/Medium/Number of Zero-Filled Subarrays.java
new file mode 100644
index 00000000..af77e188
--- /dev/null
+++ b/Medium/Number of Zero-Filled Subarrays.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public long zeroFilledSubarray(int[] nums) {
+    long count = 0;
+    long subarrayLength = 0;
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] == 0) {
+        count += ++subarrayLength;
+      } else {
+        subarrayLength = 0;
+      }
+    }
+    return count;
+  }
+}

From 61b4d226083b7771c36175ff848ab9013f2d6ab9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Jul 2022 14:44:12 -0700
Subject: [PATCH 1181/2175] Update Time Based Key-Value Store.java

---
 Medium/Time Based Key-Value Store.java | 42 +++++++++++++++++---------
 1 file changed, 28 insertions(+), 14 deletions(-)

diff --git a/Medium/Time Based Key-Value Store.java b/Medium/Time Based Key-Value Store.java
index d89b9c65..7433689e 100644
--- a/Medium/Time Based Key-Value Store.java	
+++ b/Medium/Time Based Key-Value Store.java	
@@ -1,29 +1,43 @@
 class TimeMap {
 
-  /** Initialize your data structure here. */
-  Map<String, TreeMap<Integer, String>> map;
+  private Map<String, List<TimeStampValuePair>> map;
+  
   public TimeMap() {
-    map = new HashMap<>();
+    this.map = new HashMap<>();
   }
 
   public void set(String key, String value, int timestamp) {
-    if (!map.containsKey(key)) {
-      TreeMap<Integer, String> tMap = new TreeMap<>();
-      map.put(key, tMap);
-    }
-    map.get(key).put(timestamp, value);
+    this.map.computeIfAbsent(key, k -> new ArrayList<>()).add(new TimeStampValuePair(timestamp, value));
   }
 
   public String get(String key, int timestamp) {
-    if (!map.containsKey(key)) {
+    if (!this.map.containsKey(key)) {
       return "";
     }
-    TreeMap<Integer, String> tMap = map.get(key);
-    Integer lower = tMap.floorKey(timestamp);
-    if (lower == null) {
-      return "";
+    List<TimeStampValuePair> pairs = this.map.get(key);
+    int left = 0;
+    int right = pairs.size() - 1;
+    int maxIdx = -1;
+    while (left <= right) {
+      int mid = (left + right) / 2;
+      if (pairs.get(mid).timestamp <= timestamp) {
+        maxIdx = mid;
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+    return maxIdx == -1 ? "" : pairs.get(maxIdx).value;
+  }
+  
+  private class TimeStampValuePair {
+    int timestamp;
+    String value;
+    
+    public TimeStampValuePair(int timestamp, String value) {
+      this.timestamp = timestamp;
+      this.value = value;
     }
-    return tMap.get(lower);
   }
 }
 

From 107ad9f3d1b0658886e3e058fc320193dd42089f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Jul 2022 18:19:12 -0700
Subject: [PATCH 1182/2175] Create Search a 2D Matrix II.java

---
 Medium/Search a 2D Matrix II.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Search a 2D Matrix II.java

diff --git a/Medium/Search a 2D Matrix II.java b/Medium/Search a 2D Matrix II.java
new file mode 100644
index 00000000..c409ef25
--- /dev/null
+++ b/Medium/Search a 2D Matrix II.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public boolean searchMatrix(int[][] matrix, int target) {
+    int rows = matrix.length;
+    int cols = matrix[0].length;
+    int rowIdx = rows - 1;
+    int colIdx = 0;
+    while (rowIdx >= 0 && colIdx < cols) {
+      if (matrix[rowIdx][colIdx] > target) {
+        rowIdx--;
+      } else if (matrix[rowIdx][colIdx] < target) {
+        colIdx++;
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+}

From 421e34498ec9744b73eff4837b5446f533feff87 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 24 Jul 2022 07:42:45 -0700
Subject: [PATCH 1183/2175] Create First Letter to Appear Twice.java

---
 Easy/First Letter to Appear Twice.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/First Letter to Appear Twice.java

diff --git a/Easy/First Letter to Appear Twice.java b/Easy/First Letter to Appear Twice.java
new file mode 100644
index 00000000..23a3f653
--- /dev/null
+++ b/Easy/First Letter to Appear Twice.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public char repeatedCharacter(String s) {
+    boolean[] seen = new boolean[26];
+    for (char c : s.toCharArray()) {
+      if (seen[c - 'a']) {
+        return c;
+      }
+      seen[c - 'a'] = true;
+    }
+    return ' ';
+  }
+}

From 7627e9f03c356bcc395cc52e44366b1ae4fbc687 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 25 Jul 2022 08:01:36 -0700
Subject: [PATCH 1184/2175] Create Equal Row and Column Pairs.java

---
 Medium/Equal Row and Column Pairs.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Equal Row and Column Pairs.java

diff --git a/Medium/Equal Row and Column Pairs.java b/Medium/Equal Row and Column Pairs.java
new file mode 100644
index 00000000..7c31eb66
--- /dev/null
+++ b/Medium/Equal Row and Column Pairs.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int equalPairs(int[][] grid) {
+    Map<String, Integer> map = new HashMap<>();
+    int rows = grid.length;
+    int cols = grid[0].length;
+    for (int i = 0; i < rows; i++) {
+      StringBuilder sb = new StringBuilder();
+      for (int j = 0; j < cols; j++) {
+        sb.append(grid[i][j]).append("|");
+      }
+      String key = sb.toString();
+      map.put(key, map.getOrDefault(key, 0) + 1);
+    }
+    int count = 0;
+    for (int i = 0; i < cols; i++) {
+      StringBuilder sb = new StringBuilder();
+      for (int j = 0; j < rows; j++) {
+        sb.append(grid[j][i]).append("|");
+      }
+      String key = sb.toString();
+      count += map.getOrDefault(key, 0);
+    }
+    return count;
+  }
+}

From 96662585aacead1eebd25919e070c034dd9951d8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 27 Jul 2022 10:05:44 -0700
Subject: [PATCH 1185/2175] Create Maximum Number of Events That Can Be
 Attended.java

---
 ...Number of Events That Can Be Attended.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Maximum Number of Events That Can Be Attended.java

diff --git a/Medium/Maximum Number of Events That Can Be Attended.java b/Medium/Maximum Number of Events That Can Be Attended.java
new file mode 100644
index 00000000..a69653b5
--- /dev/null
+++ b/Medium/Maximum Number of Events That Can Be Attended.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public int maxEvents(int[][] events) {
+    Arrays.sort(events, (a, b) -> a[0] - b[0]);
+    PriorityQueue<Integer> pq = new PriorityQueue<>();
+    int idx = 0;
+    int numOfEventsAttended = 0;
+    int n = events.length;
+    for (int currDay = 1; currDay <= 100000; currDay++) {
+      while (!pq.isEmpty() && pq.peek() < currDay) {
+        pq.poll();
+      }
+      while (idx < n && events[idx][0] == currDay) {
+        pq.add(events[idx++][1]);
+      }
+      if (!pq.isEmpty()) {
+        pq.poll();
+        numOfEventsAttended++;
+      }
+    }
+    return numOfEventsAttended;
+  }
+}

From 84007547f91b508bdfea227c5ab4a4cd3644557e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 27 Jul 2022 20:05:43 -0700
Subject: [PATCH 1186/2175] Rename Medium/Binary Tree Inorder Traversal.java to
 Easy/Binary Tree Inorder Traversal.java

---
 {Medium => Easy}/Binary Tree Inorder Traversal.java | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {Medium => Easy}/Binary Tree Inorder Traversal.java (100%)

diff --git a/Medium/Binary Tree Inorder Traversal.java b/Easy/Binary Tree Inorder Traversal.java
similarity index 100%
rename from Medium/Binary Tree Inorder Traversal.java
rename to Easy/Binary Tree Inorder Traversal.java

From 611e7513b6590f30e78a941cb844f96f97cc0595 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Jul 2022 10:56:51 -0700
Subject: [PATCH 1187/2175] Update Flatten 2D Vector.java

---
 Medium/Flatten 2D Vector.java | 33 ++++++++++++---------------------
 1 file changed, 12 insertions(+), 21 deletions(-)

diff --git a/Medium/Flatten 2D Vector.java b/Medium/Flatten 2D Vector.java
index d6b9b9d7..83fd6e2e 100644
--- a/Medium/Flatten 2D Vector.java	
+++ b/Medium/Flatten 2D Vector.java	
@@ -1,34 +1,25 @@
+import java.util.PrimitiveIterator.OfInt;
+
 class Vector2D {
 
-  private int[][] vec;
-  private int vecIdx;
-  private int idx;
+  private Iterator<OfInt> iterators;
+  private Iterator currIterator;
 
   public Vector2D(int[][] vec) {
-    this.vec = vec;
-    this.idx = 0;
-    this.vecIdx = 0;
-    updateIdx();
-  }
-
-  private void updateIdx() {
-    if (this.vecIdx < this.vec.length && this.idx == this.vec[this.vecIdx].length) {
-      this.idx = 0;
-      this.vecIdx++;
-    }
-    while (this.vecIdx < this.vec.length && this.vec[this.vecIdx].length == 0) {
-      this.vecIdx++;
-    }
+    this.iterators = Arrays.stream(vec).map(v -> Arrays.stream(v).iterator()).iterator();
+    this.currIterator = Collections.emptyIterator();;
   }
 
   public int next() {
-    int result = this.vec[this.vecIdx][this.idx++];
-    updateIdx();
-    return result;
+    hasNext();
+    return (int) this.currIterator.next();
   }
 
   public boolean hasNext() {
-    return this.vecIdx < this.vec.length;
+    while (!this.currIterator.hasNext() && this.iterators.hasNext()) {
+      this.currIterator = this.iterators.next();
+    }
+    return this.currIterator.hasNext();
   }
 }
 

From 52ac9e3cb49dd022fe0fe656545ef166d10c4ecf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Jul 2022 19:52:49 -0700
Subject: [PATCH 1188/2175] Create Word Subsets.java

---
 Medium/Word Subsets.java | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Word Subsets.java

diff --git a/Medium/Word Subsets.java b/Medium/Word Subsets.java
new file mode 100644
index 00000000..9c93be7d
--- /dev/null
+++ b/Medium/Word Subsets.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public List<String> wordSubsets(String[] words1, String[] words2) {
+    int[] word2MaxCount = new int[26];
+    for (String word : words2) {
+      int[] count = getFrequencyArray(word);
+      for (int i = 0; i < 26; i++) {
+        word2MaxCount[i] = Math.max(word2MaxCount[i], count[i]);
+      }
+    }
+    List<String> result = new ArrayList<>();
+    for (String word : words1) {
+      int[] count = getFrequencyArray(word);
+      for (int i = 0; i < 26; i++) {
+        if (count[i] < word2MaxCount[i]) {
+          break;
+        }
+        if (i == 25) {
+          result.add(word);
+        }
+      }
+    }
+    return result;
+  }
+  
+  private static int[] getFrequencyArray(String s) {
+    int[] count = new int[26];
+    for (char c : s.toCharArray()) {
+      count[c - 'a']++;
+    }
+    return count;
+  }
+}

From 617557c732c039a695c468d42649cd2c138dd75d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Jul 2022 15:22:08 -0700
Subject: [PATCH 1189/2175] Update Sum of Nodes with Even-Valued
 Grandparent.java

---
 ...of Nodes with Even-Valued Grandparent.java | 43 ++++++++++++-------
 1 file changed, 28 insertions(+), 15 deletions(-)

diff --git a/Medium/Sum of Nodes with Even-Valued Grandparent.java b/Medium/Sum of Nodes with Even-Valued Grandparent.java
index d2519a60..7e113144 100644
--- a/Medium/Sum of Nodes with Even-Valued Grandparent.java	
+++ b/Medium/Sum of Nodes with Even-Valued Grandparent.java	
@@ -4,25 +4,38 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  int sum;
   public int sumEvenGrandparent(TreeNode root) {
-    sum = 0;
-    helper(root, null, null);
-    return sum;
-  }
-  
-  private void helper(TreeNode root, TreeNode parent, TreeNode grandparent) {
-    if (root == null) {
-      return;
+    int sum = 0;
+    Queue<TreeNode[]> queue = new LinkedList<>();
+    queue.add(new TreeNode[]{root, null, null});
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeNode[] removed = queue.remove();
+        TreeNode node = removed[0];
+        TreeNode parent = removed[1];
+        TreeNode grandParent = removed[2];
+        if (grandParent != null && grandParent.val % 2 == 0) {
+          sum += node.val;
+        }
+        if (node.left != null) {
+          queue.add(new TreeNode[]{node.left, node, parent});
+        }
+        if (node.right != null) {
+          queue.add(new TreeNode[]{node.right, node, parent});
+        }
+      }
     }
-    if (grandparent != null && grandparent.val % 2 == 0) {
-      sum += root.val;
-    }
-    helper(root.left, root, parent);
-    helper(root.right, root, parent);
+    return sum;
   }
 }

From 34ffbccdaed47f9432fad0ff24b9d091c49e9d26 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Jul 2022 15:22:45 -0700
Subject: [PATCH 1190/2175] Update and rename Easy/Reorder Data in Log
 Files.java to Medium/Reorder Data in Log Files.java

---
 {Easy => Medium}/Reorder Data in Log Files.java | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)
 rename {Easy => Medium}/Reorder Data in Log Files.java (66%)

diff --git a/Easy/Reorder Data in Log Files.java b/Medium/Reorder Data in Log Files.java
similarity index 66%
rename from Easy/Reorder Data in Log Files.java
rename to Medium/Reorder Data in Log Files.java
index e924d7ab..cc14332b 100644
--- a/Easy/Reorder Data in Log Files.java	
+++ b/Medium/Reorder Data in Log Files.java	
@@ -3,16 +3,15 @@ public String[] reorderLogFiles(String[] logs) {
     List<String> letterLogs = new ArrayList<>();
     List<String> digitLogs = new ArrayList<>();
     for (String log : logs) {
-      String[] split = log.split("\\s+");
-      if (Character.isDigit(split[1].charAt(0))) {
+      if (Character.isDigit(log.split("\\s+")[1].charAt(0))) {
         digitLogs.add(log);
       } else {
         letterLogs.add(log);
       }
     }
     letterLogs.sort(Comparator.comparing((String o) -> o.substring(o.indexOf(' ') + 1))
-        .thenComparing(o -> o.substring(0, o.indexOf(' '))));
+        .thenComparing(o -> o.split("\\s+")[0]));
     letterLogs.addAll(digitLogs);
-    return letterLogs.toArray(new String[]{});
-  } 
+    return letterLogs.toArray(new String[0]);
+  }
 }

From 70bead34461690567182db34b1a2a3110afde5d5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Jul 2022 16:39:32 -0700
Subject: [PATCH 1191/2175] Update Number of Students Unable to Eat Lunch.java

---
 ...umber of Students Unable to Eat Lunch.java | 24 +++++++------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/Easy/Number of Students Unable to Eat Lunch.java b/Easy/Number of Students Unable to Eat Lunch.java
index 8a20c5c6..3902c4c1 100644
--- a/Easy/Number of Students Unable to Eat Lunch.java	
+++ b/Easy/Number of Students Unable to Eat Lunch.java	
@@ -1,21 +1,13 @@
 class Solution {
   public int countStudents(int[] students, int[] sandwiches) {
-    int studentIdx = 0;
-    int sandwichIdx = 0;
-    Map<Integer, Integer> studentState = new HashMap<>();
-    while (sandwichIdx < sandwiches.length) {
-      if (sandwiches[sandwichIdx] == students[studentIdx]) {
-        sandwichIdx++;
-        students[studentIdx] = -1;
-      } else if (students[studentIdx] != -1) {
-        // Check to see if we have finished one complete iteration without consuming any sandwich
-        if (studentState.containsKey(studentIdx) && studentState.get(studentIdx) == sandwichIdx) {
-          break;
-        }
-        studentState.put(studentIdx, sandwichIdx);
-      }
-      studentIdx = studentIdx == students.length - 1 ? 0 : studentIdx + 1;
+    int[] preferenceCount = new int[2];
+    for (int preference : students) {
+      preferenceCount[preference]++;
     }
-    return sandwichIdx == sandwiches.length ? 0 : sandwiches.length - sandwichIdx;
+    int i = 0;
+    for (i = 0; i < sandwiches.length && preferenceCount[sandwiches[i]] > 0; i++) {
+      preferenceCount[sandwiches[i]]--;
+    }
+    return sandwiches.length - i; 
   }
 }

From 25de70cc455d2f14d595c5276cde5dcc64ceb12f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Jul 2022 16:40:01 -0700
Subject: [PATCH 1192/2175] Update Insert into a Binary Search Tree.java

---
 Medium/Insert into a Binary Search Tree.java | 27 ++++++++++++++------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/Medium/Insert into a Binary Search Tree.java b/Medium/Insert into a Binary Search Tree.java
index 7131fd50..c7d1015b 100644
--- a/Medium/Insert into a Binary Search Tree.java	
+++ b/Medium/Insert into a Binary Search Tree.java	
@@ -12,16 +12,27 @@
  *         this.right = right;
  *     }
  * }
-*/
+ */
 class Solution {
   public TreeNode insertIntoBST(TreeNode root, int val) {
-    if (root == null) {
-      return new TreeNode(val);
-    } else if (root.val < val) {
-      root.right = insertIntoBST(root.right, val);
-    } else {
-      root.left = insertIntoBST(root.left, val);
+    TreeNode node = root;
+    while (node != null) {
+      if (val > node.val) {
+        if (node.right == null) {
+          node.right = new TreeNode(val);
+          return root;
+        } else {
+          node = node.right;
+        }
+      } else {
+        if (node.left == null) {
+          node.left = new TreeNode(val);
+          return root;
+        } else {
+          node = node.left;
+        }
+      }
     }
-    return root;
+    return new TreeNode(val);
   }
 }

From eb7a9a24fa5d3c91d94f61cd98ba06b66b26b832 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Jul 2022 07:13:13 -0700
Subject: [PATCH 1193/2175] Create Make Array Zero by Subtracting Equal
 Amounts.java

---
 Easy/Make Array Zero by Subtracting Equal Amounts.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Make Array Zero by Subtracting Equal Amounts.java

diff --git a/Easy/Make Array Zero by Subtracting Equal Amounts.java b/Easy/Make Array Zero by Subtracting Equal Amounts.java
new file mode 100644
index 00000000..304e3e92
--- /dev/null
+++ b/Easy/Make Array Zero by Subtracting Equal Amounts.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public int minimumOperations(int[] nums) {
+    return Arrays.stream(nums).boxed().filter(n -> n > 0).collect(Collectors.toSet()).size();
+  }
+}

From 6a8443fcb6f617dde928d2ee7ef708700f6f1071 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Jul 2022 07:34:27 -0700
Subject: [PATCH 1194/2175] Update Range Sum Query - Mutable.java

---
 Medium/Range Sum Query - Mutable.java | 107 +++++++++++---------------
 1 file changed, 43 insertions(+), 64 deletions(-)

diff --git a/Medium/Range Sum Query - Mutable.java b/Medium/Range Sum Query - Mutable.java
index 0ff8bbbb..5faab61f 100644
--- a/Medium/Range Sum Query - Mutable.java	
+++ b/Medium/Range Sum Query - Mutable.java	
@@ -1,71 +1,50 @@
 class NumArray {
-    int[] fen;
-    int[] nums;
-    int n;
-    public NumArray(int[] nums) {
-        this.nums = nums;
-        n = nums.length;
-        fen = new int[n + 1];
-        init();
-    }
-
-    private void init () {
-        if (n == 0) {
-            return;
-        }
-
-        // Compute the pre-sum
-        fen[1] = nums[0];
-        for (int i = 1; i < n; i++) {
-            fen[i + 1] = fen[i] + nums[i];
-        }
-
-        for (int i = n; i > 0; i--) {
-            // Removing the value of parent for each node
-            int parent = i - (i & -i);
-            if (parent >= 0) {
-                fen[i] -= fen[parent];
-            }
-        }
-    }
-
-    public void update(int i, int val) {
-        // Find the difference between previous and current value
-        int extra = val - nums[i];
-
-        // Update the actual array with the new val
-        nums[i] = val;
-
-        // Update the tree with the extra value to all the parents 
-        increment(i, extra);
-    }
-
-    private void increment (int i, int extra) {
-        i++;
-        while (i <= n) {
-            fen[i] += extra;
-            i = i + (i & -i);
-        }
-    }
-
-    public int sumRange(int i, int j) {
-        // Similar to pre sum from 0 to j - pre sum from 0 to i
-        return getSum(j + 1) - getSum(i);
-    }
-
-    private int getSum (int i) {
-        int res = 0;
-        while (i > 0) {
-            res += fen[i];
-            i = i - (i & -i);
-        }
-
-        return res;
+  
+  private int[] nums;
+  private int[] indexTree;
+  private int n;
+  
+  public NumArray(int[] nums) {
+    this.nums = nums;
+    this.n = nums.length;
+    this.indexTree = new int[n + 1];
+    for (int i = 0; i < n; i++) {
+      initialize(i, nums[i]);
     }
+  }
+
+  public void update(int index, int val) {
+    int diff = val - this.nums[index];
+		this.nums[index] = val;
+		initialize(index, diff);
+  }
+
+  public int sumRange(int left, int right) {
+    return getSum(right) - getSum(left - 1);
+  }
+  
+  private void initialize(int idx, int value) {
+		idx++;
+		while (idx <= this.n) {
+			this.indexTree[idx] += value;
+			idx += (idx & -idx);
+		}
+  }
+  
+  private int getSum(int i) {
+		int sum = 0;
+		i++;
+		while (i > 0) {
+			sum += this.indexTree[i];
+			i -= (i & -i);
+		}
+		return sum;
+	}
 }
+
 /**
  * Your NumArray object will be instantiated and called as such:
  * NumArray obj = new NumArray(nums);
- * obj.update(i,val);
- * int param_2 = obj.sumRange(i,j);
+ * obj.update(index,val);
+ * int param_2 = obj.sumRange(left,right);
  */

From b9182ea9715a7ef6327d40e1d2601dfb0846a846 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Jul 2022 14:14:20 -0700
Subject: [PATCH 1195/2175] Create Maximum Number of Groups Entering a
 Competition.java

---
 ...mum Number of Groups Entering a Competition.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Maximum Number of Groups Entering a Competition.java

diff --git a/Medium/Maximum Number of Groups Entering a Competition.java b/Medium/Maximum Number of Groups Entering a Competition.java
new file mode 100644
index 00000000..a1794f7a
--- /dev/null
+++ b/Medium/Maximum Number of Groups Entering a Competition.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int maximumGroups(int[] grades) {
+    int numOfGroups = 0;
+    int n = grades.length;
+    int groupSize = 1;
+    int totalGrades = 0;
+    while (totalGrades < n) {
+      totalGrades += ++groupSize;
+      numOfGroups++;
+    }
+    return numOfGroups;
+  }
+}

From 167f3df745c8c151e780a774cb019b84c9ebb32a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 1 Aug 2022 07:52:49 -0700
Subject: [PATCH 1196/2175] Update Find Permutation.java

---
 Medium/Find Permutation.java | 38 ++++++++++++++++++++----------------
 1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/Medium/Find Permutation.java b/Medium/Find Permutation.java
index 2103c84f..0a081e7c 100644
--- a/Medium/Find Permutation.java	
+++ b/Medium/Find Permutation.java	
@@ -1,23 +1,27 @@
 class Solution {
   public int[] findPermutation(String s) {
-    int[] ans = new int[s.length() + 1];
-    Stack<Integer> stack = new Stack<>();
-    int idx = 0;
-    for (int i = 1; i <= s.length(); i++) {
-      if (s.charAt(i - 1) == 'I') {
-        stack.push(i);
-        while (!stack.isEmpty()) {
-          ans[idx++] = stack.pop();
-        }
-      }
-      else {
-        stack.push(i);
+    int n = s.length();
+    int[] result = new int[n + 1];
+    for (int i = 0; i < result.length; i++) {
+      result[i] = i + 1;
+    }
+    int idx = 1;
+    while (idx <= n) {
+      int k = idx;
+      while (idx <= n && s.charAt(idx - 1) == 'D') {
+        idx++;
       }
+      reverse(result, k - 1, idx);
+      idx++;
     }
-    stack.push(s.length() + 1);
-    while (!stack.isEmpty()) {
-      ans[idx++] = stack.pop();
+    return result;
+  }
+  
+  private void reverse(int[] result, int start, int end) {
+    for (int i = 0; i < (end - start) / 2; i++) {
+      int temp = result[i + start];
+      result[i + start] = result[end - i - 1];
+      result[end - i - 1] = temp;
     }
-    return ans;
-  } 
+  }
 }

From 822e5a2ab524938dc2c94becb195d75d9087511b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 1 Aug 2022 10:24:43 -0700
Subject: [PATCH 1197/2175] Update Monotonic Array.java

---
 Easy/Monotonic Array.java | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/Easy/Monotonic Array.java b/Easy/Monotonic Array.java
index c523cef1..4a348d71 100644
--- a/Easy/Monotonic Array.java	
+++ b/Easy/Monotonic Array.java	
@@ -1,17 +1,20 @@
 class Solution {
   public boolean isMonotonic(int[] nums) {
-    if (nums.length < 2) {
-      return true;
-    }
-    Boolean increasing = null;
-    for (int i = 1; i < nums.length; i++) {
-      if (nums[i] == nums[i - 1] && increasing == null) {
-        continue;
+    int idx = 0;
+    int sign = 0;
+    while (idx < nums.length - 1 && sign == 0) {
+      if (nums[idx] < nums[idx + 1]) {
+        sign = 1;
+      } else if (nums[idx] > nums[idx + 1]) {
+        sign = -1;
       }
-      increasing = increasing == null ? nums[i] > nums[i - 1] : increasing;
-      if ((nums[i] > nums[i - 1] && !increasing) || (nums[i] < nums[i - 1] && increasing)) {
+      idx++;
+    }
+    while (idx < nums.length - 1) {
+      if ((sign == 1 && nums[idx] > nums[idx + 1]) || (sign == -1 && nums[idx] < nums[idx + 1])) {
         return false;
       }
+      idx++;
     }
     return true;
   }

From 69b93f9a36248173bf152b5dbf4cadd45209b667 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 1 Aug 2022 12:11:25 -0700
Subject: [PATCH 1198/2175] Update 3Sum.java

---
 Medium/3Sum.java | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/Medium/3Sum.java b/Medium/3Sum.java
index d054e15a..fc4f25fa 100644
--- a/Medium/3Sum.java
+++ b/Medium/3Sum.java
@@ -1,22 +1,21 @@
 class Solution {
   public List<List<Integer>> threeSum(int[] nums) {
-    Arrays.sort(nums);
-    List<List<Integer>> result = new ArrayList<>();
-    for (int i = 0; i < nums.length && nums[i] <= 0; i++) {
-      if (i == 0 || nums[i - 1] != nums[i]) {
-        Set<Integer> set = new HashSet<>();
+    Set<List<Integer>> result = new HashSet<>();
+    Set<Integer> duplicates = new HashSet<>();
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+      if (duplicates.add(nums[i])) {
         for (int j = i + 1; j < nums.length; j++) {
-          int target = -1 * (nums[i] + nums[j]);
-          if (set.contains(target)) {
-            result.add(Arrays.asList(nums[i], nums[j], target));
-            while (j + 1 < nums.length && nums[j] == nums[j + 1]) {
-              j++;
-            }
+          int target = -nums[i] - nums[j];
+          if (map.containsKey(target) && map.get(target) == i) {
+            List<Integer> temp = Arrays.asList(nums[i], nums[j], target);
+            Collections.sort(temp);
+            result.add(temp);
           }
-          set.add(nums[j]);
+          map.put(nums[j], i);
         }
       }
     }
-    return result;
+    return new ArrayList<>(result);
   }
 }

From 759fd3a55b7da740915eb668941c58168ce00c73 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 1 Aug 2022 13:49:00 -0700
Subject: [PATCH 1199/2175] Update Fruit Into Baskets.java

---
 Medium/Fruit Into Baskets.java | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/Medium/Fruit Into Baskets.java b/Medium/Fruit Into Baskets.java
index ad4dba0b..79889371 100644
--- a/Medium/Fruit Into Baskets.java	
+++ b/Medium/Fruit Into Baskets.java	
@@ -1,22 +1,21 @@
 class Solution {
-  public int totalFruit(int[] tree) {
+  public int totalFruit(int[] fruits) {
     Map<Integer, Integer> map = new HashMap<>();
-    int maxCount = 0;
-    int start = 0;
-    int end = 0;
-    int n = tree.length;
-    while (end < n) {
-      map.put(tree[end], map.getOrDefault(tree[end], 0) + 1);
-      while (map.size() > 2) {
-        map.put(tree[start], map.get(tree[start]) - 1);
-        if (map.get(tree[start]) == 0) {
-          map.remove(tree[start]);
+    int startIdx = 0;
+    int endIdx = 0;
+    int n = fruits.length;
+    int maxPickedCount = 0;
+    while (endIdx < n) {
+      map.put(fruits[endIdx], map.getOrDefault(fruits[endIdx++], 0) + 1);
+      while (startIdx < endIdx && map.size() > 2) {
+        map.put(fruits[startIdx], map.get(fruits[startIdx]) - 1);
+        if (map.get(fruits[startIdx]) == 0) {
+          map.remove(fruits[startIdx]);
         }
-        start++;
+        startIdx++;
       }
-      end++;
-      maxCount = Math.max(maxCount, end - start);
+      maxPickedCount = Math.max(maxPickedCount, endIdx - startIdx);
     }
-    return maxCount;
-  }
+    return maxPickedCount;
+  }   
 }

From c84515c81a4f6c43625bd93b6cc24f108ecd2b1e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 2 Aug 2022 08:37:31 -0700
Subject: [PATCH 1200/2175] Update Kth Smallest Element in a Sorted Matrix.java

---
 Medium/Kth Smallest Element in a Sorted Matrix.java | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/Medium/Kth Smallest Element in a Sorted Matrix.java b/Medium/Kth Smallest Element in a Sorted Matrix.java
index 1eaf99e7..37054ddf 100644
--- a/Medium/Kth Smallest Element in a Sorted Matrix.java	
+++ b/Medium/Kth Smallest Element in a Sorted Matrix.java	
@@ -1,11 +1,7 @@
 class Solution {
   public int kthSmallest(int[][] matrix, int k) {
     int numOfRows = matrix.length;
-    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
-      public int compare(int[] o1, int[] o2) {
-        return o1[2] - o2[2];
-      }
-    });
+    PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[2] - o2[2]);
     for (int j = 0; j < numOfRows; j++) {
       pq.add(new int[]{0, j, matrix[0][j]});
     }

From 13cdaa8f05cca51504c46ebe0a9b469d1623451b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 2 Aug 2022 15:59:47 -0700
Subject: [PATCH 1201/2175] Update Average of Levels in Binary Tree.java

---
 Easy/Average of Levels in Binary Tree.java | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/Easy/Average of Levels in Binary Tree.java b/Easy/Average of Levels in Binary Tree.java
index dad5fc3e..28bd78a2 100644
--- a/Easy/Average of Levels in Binary Tree.java	
+++ b/Easy/Average of Levels in Binary Tree.java	
@@ -15,18 +15,15 @@
  */
 class Solution {
   public List<Double> averageOfLevels(TreeNode root) {
-    List<Double> averages = new ArrayList<>();
-    if (root == null) {
-      return averages;
-    }
+    List<Double> result = new ArrayList<>();
     Queue<TreeNode> queue = new LinkedList<>();
     queue.add(root);
     while (!queue.isEmpty()) {
-      long sum = 0;
       int size = queue.size();
+      double total = 0.0;
       for (int i = 0; i < size; i++) {
         TreeNode removed = queue.remove();
-        sum += removed.val;
+        total += removed.val;
         if (removed.left != null) {
           queue.add(removed.left);
         }
@@ -34,8 +31,8 @@ public List<Double> averageOfLevels(TreeNode root) {
           queue.add(removed.right);
         }
       }
-      averages.add(((double) sum) / size);
+      result.add(total / size);
     }
-    return averages;
+    return result;
   }
 }

From 3a95bfa764a12361f428fc55043eb8594e64e76b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 3 Aug 2022 15:58:08 -0700
Subject: [PATCH 1202/2175] Update Pascal's Triangle II.java

---
 Easy/Pascal's Triangle II.java | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/Easy/Pascal's Triangle II.java b/Easy/Pascal's Triangle II.java
index 219b923a..9890275c 100644
--- a/Easy/Pascal's Triangle II.java	
+++ b/Easy/Pascal's Triangle II.java	
@@ -1,21 +1,17 @@
 class Solution {
   public List<Integer> getRow(int rowIndex) {
-    int count = 0;
-    List<Integer> list = new ArrayList<>();
-    List<Integer> prev = new ArrayList<>();
+    List<Integer> lastRow = new ArrayList<>();
     for (int i = 0; i <= rowIndex; i++) {
-      prev = list;
-      List<Integer> temp = new ArrayList<>();
+      List<Integer> copy = new ArrayList<>(lastRow);
+      lastRow.clear();
       for (int j = 0; j <= i; j++) {
         if (j == 0 || j == i) {
-          temp.add(1);
-        }
-        else {
-          temp.add(prev.get(j - 1) + prev.get(j));
+          lastRow.add(1);
+        } else {
+          lastRow.add(copy.get(j - 1) + copy.get(j));
         }
       }
-      list = temp;
     }
-    return list;
+    return lastRow;
   }   
 }

From 152c7a270d5a260e3f3dfe624eb0b4ed71c649cb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Aug 2022 07:56:05 -0700
Subject: [PATCH 1203/2175] Create Mirror Reflection.java

---
 Medium/Mirror Reflection.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Mirror Reflection.java

diff --git a/Medium/Mirror Reflection.java b/Medium/Mirror Reflection.java
new file mode 100644
index 00000000..c5577abc
--- /dev/null
+++ b/Medium/Mirror Reflection.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int mirrorReflection(int p, int q) {
+    int extention = q;
+    int reflection = p;
+    while (extention % 2 == 0 && reflection % 2 == 0) {
+      extention /= 2;
+      reflection /= 2;
+    }
+    if (extention % 2 == 0 && reflection % 2 != 0) {
+      return 0;
+    } else if (extention % 2 != 0 && reflection % 2 == 0) {
+      return 2;
+    } else {
+      return 1;
+    }
+  }
+}

From aef8f1a2b17e19337f263acf55d840cfa2dbe6be Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Aug 2022 08:08:49 -0700
Subject: [PATCH 1204/2175] Update Base 7.java

---
 Easy/Base 7.java | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/Easy/Base 7.java b/Easy/Base 7.java
index 88c05c8a..210d6c39 100644
--- a/Easy/Base 7.java	
+++ b/Easy/Base 7.java	
@@ -1,12 +1,16 @@
 class Solution {
-    public String convertToBase7(int num) {
-        if (num == 0) return "0";
-        int temp = Math.abs(num);
-        StringBuilder sb = new StringBuilder("");
-        while (temp > 0) {
-            sb.append(String.valueOf(temp%7));
-            temp /= 7;
-        }
-        return num < 0 ? "-" + sb.reverse().toString() : sb.reverse().toString();
+  public String convertToBase7(int num) {
+    StringBuilder sb = new StringBuilder();
+    char sign = num < 0 ? '-' : ' ';
+    num = Math.abs(num);
+    while (num > 0) {
+      sb.append(num % 7);
+      num /= 7;
     }
+    String representation = sb.length() == 0 ? "0" : sb.reverse().toString();
+    if (sign == '-') {
+      return sign + representation;
+    }
+    return representation;
+  }
 }

From cd66f4149f7d0795b875f4ce78ae6d325d5b2d13 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Aug 2022 08:09:44 -0700
Subject: [PATCH 1205/2175] Update Binary Search Tree to Greater Sum Tree.java

---
 ...inary Search Tree to Greater Sum Tree.java | 38 +++++++++----------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/Medium/Binary Search Tree to Greater Sum Tree.java b/Medium/Binary Search Tree to Greater Sum Tree.java
index 91c63aa7..912e0699 100644
--- a/Medium/Binary Search Tree to Greater Sum Tree.java	
+++ b/Medium/Binary Search Tree to Greater Sum Tree.java	
@@ -4,32 +4,30 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public TreeNode bstToGst(TreeNode root) {
-    if (root == null) {
-      return null;
-    }
-    TreeNode curr = root;
-    Stack<TreeNode> stack = new Stack<>();
     int sum = 0;
-    pushRight(stack, curr);
-    while (!stack.isEmpty()) {
-      TreeNode removed = stack.pop();
-      sum += removed.val;
-      removed.val = sum;
-      TreeNode leftNode = removed.left;
-      pushRight(stack, leftNode);
+    TreeNode node = root;
+    Stack<TreeNode> stack = new Stack<>();
+    while (!stack.isEmpty() || node != null) {
+      while (node != null) {
+        stack.add(node);
+        node = node.right;
+      }
+      node = stack.pop();
+      sum += node.val;
+      node.val = sum;
+      node = node.left;
     }
     return root;
   }
-  
-  private void pushRight(Stack<TreeNode> stack, TreeNode curr) {
-    while (curr != null) {
-      stack.push(curr);
-      curr = curr.right;
-    }
-  }
 }

From ffee8b820eeda381fdbbdb4adc93c76ff1478e25 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Aug 2022 08:22:06 -0700
Subject: [PATCH 1206/2175] Update Linked List in Binary Tree.java

---
 Medium/Linked List in Binary Tree.java | 32 +++++++++++++++-----------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/Medium/Linked List in Binary Tree.java b/Medium/Linked List in Binary Tree.java
index 065a25c3..9ba90a87 100644
--- a/Medium/Linked List in Binary Tree.java	
+++ b/Medium/Linked List in Binary Tree.java	
@@ -3,7 +3,9 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 /**
@@ -12,31 +14,33 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
   public boolean isSubPath(ListNode head, TreeNode root) {
+    if (head == null) {
+      return true;
+    }
     if (root == null) {
       return false;
     }
-    return (
-      helper(head, root) ||
-      isSubPath(head, root.left) ||
-      isSubPath(head, root.right)
-    );
-  } 
+    return dfs(head, root) || isSubPath(head, root.left) || isSubPath(head, root.right);
+  }
   
-  private boolean helper(ListNode head, TreeNode root) {
+  private boolean dfs(ListNode head, TreeNode root) {
     if (head == null) {
       return true;
     }
-    if (head != null && root == null) {
-      return false;
-    }
-    if (head.val != root.val) {
+    if (root == null) {
       return false;
     }
-    return helper(head.next, root.left) || helper(head.next, root.right);
+    return head.val == root.val && (dfs(head.next, root.left) || dfs(head.next, root.right));
   }
 }

From 5154e4d401fc0f95abaea6eda46a166a9f18023a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Aug 2022 17:32:25 -0700
Subject: [PATCH 1207/2175] Create Traffic Light Controlled Intersection.java

---
 ...Traffic Light Controlled Intersection.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Concurrency/Traffic Light Controlled Intersection.java

diff --git a/Concurrency/Traffic Light Controlled Intersection.java b/Concurrency/Traffic Light Controlled Intersection.java
new file mode 100644
index 00000000..3328a2e8
--- /dev/null
+++ b/Concurrency/Traffic Light Controlled Intersection.java	
@@ -0,0 +1,26 @@
+class TrafficLight {
+
+  private boolean greenOnRoadA;
+  private ReentrantLock lock;
+  
+  public TrafficLight() {
+    this.greenOnRoadA = true;
+    this.lock = new ReentrantLock();
+  }
+
+  public void carArrived(
+      int carId,           // ID of the car
+      int roadId,          // ID of the road the car travels on. Can be 1 (road A) or 2 (road B)
+      int direction,       // Direction of the car
+      Runnable turnGreen,  // Use turnGreen.run() to turn light to green on current road
+      Runnable crossCar    // Use crossCar.run() to make car cross the intersection 
+  ) {
+    this.lock.lock();
+    if(greenOnRoadA && roadId==2 || !greenOnRoadA && roadId==1){
+      greenOnRoadA = !greenOnRoadA;
+      turnGreen.run();
+    }
+    crossCar.run();
+    this.lock.unlock();     
+  }
+}

From 2f8fc2271bf1b5200234b835c459f92d07e09c77 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 5 Aug 2022 07:54:38 -0700
Subject: [PATCH 1208/2175] Create Combination Sum IV.java

---
 Medium/Combination Sum IV.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Combination Sum IV.java

diff --git a/Medium/Combination Sum IV.java b/Medium/Combination Sum IV.java
new file mode 100644
index 00000000..bc8c1924
--- /dev/null
+++ b/Medium/Combination Sum IV.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int combinationSum4(int[] nums, int target) {
+    Integer[] dp = new Integer[target + 1];
+    return getCount(target, nums, dp);
+  }
+  
+  public int getCount(int target, int[] nums, Integer[] dp) {
+    if (dp[target] != null) {
+      return dp[target];
+    }
+    if (target == 0) {
+      return 1;
+    }
+    if (target < 0) {
+      return 0;
+    }
+    int total = 0;
+    for (int num : nums) {
+      if (target >= num) {
+        total += getCount(target - num, nums, dp);
+      }
+    }
+    return dp[target] = total;
+  }
+}

From 7fa03479dd410655e14e613f51c71e698ee02090 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 5 Aug 2022 08:02:06 -0700
Subject: [PATCH 1209/2175] Update Remove Linked List Elements.java

---
 Easy/Remove Linked List Elements.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Easy/Remove Linked List Elements.java b/Easy/Remove Linked List Elements.java
index 9bc15504..41684468 100644
--- a/Easy/Remove Linked List Elements.java	
+++ b/Easy/Remove Linked List Elements.java	
@@ -10,16 +10,16 @@
  */
 class Solution {
   public ListNode removeElements(ListNode head, int val) {
-    while (head != null && head.val == val) {
-      head = head.next;
+    ListNode newHead = null;
+    ListNode curr = head;
+    while (curr != null && curr.val == val) {
+      curr = curr.next;
     }
-    ListNode newHead = head;
-    ListNode curr = newHead;
+    newHead = curr;
     while (curr != null && curr.next != null) {
       if (curr.next.val == val) {
         curr.next = curr.next.next;
-      }
-      else {
+      } else {
         curr = curr.next;
       }
     }

From 8ca5525f53b1d3e7ee5419c35cd5d45e8c63fd12 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 5 Aug 2022 08:08:36 -0700
Subject: [PATCH 1210/2175] Update Check if Array Is Sorted and Rotated.java

---
 Easy/Check if Array Is Sorted and Rotated.java | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/Easy/Check if Array Is Sorted and Rotated.java b/Easy/Check if Array Is Sorted and Rotated.java
index 4016c5b1..6ecc109d 100644
--- a/Easy/Check if Array Is Sorted and Rotated.java	
+++ b/Easy/Check if Array Is Sorted and Rotated.java	
@@ -1,17 +1,14 @@
 class Solution {
   public boolean check(int[] nums) {
-    boolean rotationFound = false;
+    boolean rotated = false;
     for (int i = 0; i < nums.length - 1; i++) {
       if (nums[i] > nums[i + 1]) {
-        if (rotationFound) {
+        if (rotated) {
           return false;
         }
-        rotationFound = true;
+        rotated = true;
       }
     }
-    if (rotationFound && nums[nums.length - 1] > nums[0]) {
-      return false;
-    }
-    return true;
+    return !rotated || nums[nums.length - 1] <= nums[0];
   }
 }

From 9689c9cdbf9a1e4466376b7cf5924c9f5de2f3e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 6 Aug 2022 08:04:50 -0700
Subject: [PATCH 1211/2175] Create Poor Pigs.java

---
 Hard/Poor Pigs.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Hard/Poor Pigs.java

diff --git a/Hard/Poor Pigs.java b/Hard/Poor Pigs.java
new file mode 100644
index 00000000..275fb45a
--- /dev/null
+++ b/Hard/Poor Pigs.java	
@@ -0,0 +1,6 @@
+class Solution {
+  public int poorPigs(int buckets, int minutesToDie, int minutesToTest) {
+    int states = minutesToTest / minutesToDie + 1;
+    return (int) Math.ceil(Math.log(buckets) / Math.log(states));
+  }
+}

From e686534a2ec71215a98b45098a7138676b3cbc75 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Aug 2022 07:24:24 -0700
Subject: [PATCH 1212/2175] Create Count Vowels Permutation.java

---
 Hard/Count Vowels Permutation.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Hard/Count Vowels Permutation.java

diff --git a/Hard/Count Vowels Permutation.java b/Hard/Count Vowels Permutation.java
new file mode 100644
index 00000000..a0a2c36c
--- /dev/null
+++ b/Hard/Count Vowels Permutation.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public int countVowelPermutation(int n) {
+    long aCount = 1;
+    long eCount = 1;
+    long iCount = 1;
+    long oCount = 1;
+    long uCount = 1;
+    final int MOD = 1000000007;
+    for (int i = 1; i < n; i++) {
+      long aCountNew = (eCount + iCount + uCount) % MOD;
+      long eCountNew = (aCount + iCount) % MOD;
+      long iCountNew = (eCount + oCount) % MOD;
+      long oCountNew = (iCount) % MOD;
+      long uCountNew = (iCount + oCount) % MOD;
+      aCount = aCountNew;
+      eCount = eCountNew;
+      iCount = iCountNew;
+      oCount = oCountNew;
+      uCount = uCountNew;
+    }
+    long result = (aCount + eCount + iCount + oCount + uCount) % MOD;
+    return (int) result;
+  }
+}

From f68218e6f086be2b9126ad6e64ae9180b5607429 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Aug 2022 08:03:48 -0700
Subject: [PATCH 1213/2175] Create Merge Similar Items.java

---
 Easy/Merge Similar Items.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Merge Similar Items.java

diff --git a/Easy/Merge Similar Items.java b/Easy/Merge Similar Items.java
new file mode 100644
index 00000000..d9f95996
--- /dev/null
+++ b/Easy/Merge Similar Items.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public List<List<Integer>> mergeSimilarItems(int[][] items1, int[][] items2) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int[] item : items1) {
+      map.put(item[0], map.getOrDefault(item[0], 0) + item[1]);
+    }
+    for (int[] item : items2) {
+      map.put(item[0], map.getOrDefault(item[0], 0) + item[1]);
+    }
+    List<List<Integer>> result = new ArrayList<>();
+    for (Integer key : map.keySet()) {
+      result.add(Arrays.asList(key, map.get(key)));
+    }
+    Collections.sort(result, Comparator.comparing(o -> o.get(0)));
+    return result;
+  }
+}

From 2c654bd46ae6285f15517f09aae683ffd0d09f69 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Aug 2022 08:09:12 -0700
Subject: [PATCH 1214/2175] Create Number of Arithmetic Triplets.java

---
 Easy/Number of Arithmetic Triplets.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Number of Arithmetic Triplets.java

diff --git a/Easy/Number of Arithmetic Triplets.java b/Easy/Number of Arithmetic Triplets.java
new file mode 100644
index 00000000..8094d932
--- /dev/null
+++ b/Easy/Number of Arithmetic Triplets.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int arithmeticTriplets(int[] nums, int diff) {
+    int count = 0;
+    Set<Integer> set = new HashSet<>();
+    for (int num : nums) {
+      if (set.contains(num - diff) && set.contains(num - 2 * diff)) {
+        count++;
+      }
+      set.add(num);
+    }
+    return count;
+  }
+}

From 4d9c7783fdf35961c0a5696727ff58c691887135 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Aug 2022 09:24:02 -0700
Subject: [PATCH 1215/2175] Create Count Number of Bad Pairs.java

---
 Medium/Count Number of Bad Pairs.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Count Number of Bad Pairs.java

diff --git a/Medium/Count Number of Bad Pairs.java b/Medium/Count Number of Bad Pairs.java
new file mode 100644
index 00000000..e1002897
--- /dev/null
+++ b/Medium/Count Number of Bad Pairs.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public long countBadPairs(int[] nums) {
+    long result = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+      int prevCount = map.getOrDefault(i - nums[i], 0);
+      result += i - prevCount;
+      map.put(i - nums[i], prevCount + 1);
+    }
+    return result;
+  }
+}

From a19ff6cc3b70f2459251fb8ee41c3fc1b1719f89 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Aug 2022 09:34:03 -0700
Subject: [PATCH 1216/2175] Create Reachable Nodes With Restrictions.java

---
 Medium/Reachable Nodes With Restrictions.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Reachable Nodes With Restrictions.java

diff --git a/Medium/Reachable Nodes With Restrictions.java b/Medium/Reachable Nodes With Restrictions.java
new file mode 100644
index 00000000..2a9b6f85
--- /dev/null
+++ b/Medium/Reachable Nodes With Restrictions.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public int reachableNodes(int n, int[][] edges, int[] restricted) {
+    Map<Integer, List<Integer>> graph = new HashMap<>();
+    for (int[] edge : edges) {
+      graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    }
+    Set<Integer> restrictedSet = Arrays.stream(restricted).boxed().collect(Collectors.toSet());
+    Set<Integer> visited = new HashSet<>();
+    Queue<Integer> queue = new LinkedList<>();
+    queue.add(0);
+    visited.add(0);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        int node = queue.remove();
+        for (Integer neighbor : graph.getOrDefault(node, new ArrayList<>())) {
+          if (restrictedSet.contains(neighbor) || visited.contains(neighbor)) {
+            continue;
+          }
+          queue.add(neighbor);
+          visited.add(neighbor);
+        }
+      }
+    }
+    return visited.size();
+  }
+}

From d250b89e49334aa94a008b2029333af6507f8a15 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Aug 2022 14:33:52 -0700
Subject: [PATCH 1217/2175] Update Add to Array-Form of Integer.java

---
 Easy/Add to Array-Form of Integer.java | 25 ++++++++++---------------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/Easy/Add to Array-Form of Integer.java b/Easy/Add to Array-Form of Integer.java
index c1ab95b2..1ef362dd 100644
--- a/Easy/Add to Array-Form of Integer.java	
+++ b/Easy/Add to Array-Form of Integer.java	
@@ -1,20 +1,15 @@
 class Solution {
-  public List<Integer> addToArrayForm(int[] A, int K) {
-    List<Integer> list = new ArrayList<>();
-    int idx = A.length - 1;
+  public List<Integer> addToArrayForm(int[] num, int k) {
     int carry = 0;
-    while (K > 0 || idx >= 0 || carry > 0) {
-      int temp = (
-        (K > 0 ? K % 10 : 0) +
-        (idx >= 0 ? A[idx--] : 0) + 
-        carry
-      );
-      K /= 10;
-      carry = temp > 9 ? temp / 10 : 0;
-      temp = temp > 9 ? temp % 10 : temp;
-      list.add(temp);
+    int idx = num.length - 1;
+    List<Integer> result = new ArrayList<>();
+    while (idx >= 0 || carry > 0 || k > 0) {
+      int temp = k % 10 + carry + (idx >= 0 ? num[idx--] : 0);
+      result.add(temp % 10);
+      carry = temp / 10;
+      k /= 10;
     }
-    Collections.reverse(list);
-    return list;
+    Collections.reverse(result);
+    return result;
   }
 }

From c3cff3623ff8c2226b7634786d61a02e5fed8b4b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Aug 2022 07:52:40 -0700
Subject: [PATCH 1218/2175] Create Binary Trees With Factors.java

---
 Medium/Binary Trees With Factors.java | 29 +++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Binary Trees With Factors.java

diff --git a/Medium/Binary Trees With Factors.java b/Medium/Binary Trees With Factors.java
new file mode 100644
index 00000000..be7e38be
--- /dev/null
+++ b/Medium/Binary Trees With Factors.java	
@@ -0,0 +1,29 @@
+class Solution {
+  private final int MOD = 1_000_000_007;
+  
+  public int numFactoredBinaryTrees(int[] arr) {
+    int n = arr.length;
+    Arrays.sort(arr);
+    long[] dp = new long[n];
+    Arrays.fill(dp, 1);
+    Map<Integer, Integer> indexMap = new HashMap<>();
+    for (int i = 0; i < n; i++) {
+      indexMap.put(arr[i], i);
+    }
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < i; j++) {
+        if (arr[i] % arr[j] == 0) {
+          int right = arr[i] / arr[j];
+          if (indexMap.containsKey(right)) {
+            dp[i] = (dp[i] + dp[j] * dp[indexMap.get(right)]) % MOD;
+          }
+        }
+      }
+    }
+    long result = 0;
+    for (long count : dp) {
+      result += count;
+    }
+    return (int) (result % MOD);
+  }
+}

From 7956534e059b43572a979fad599b932481b6e454 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Aug 2022 14:14:55 -0700
Subject: [PATCH 1219/2175] Update Add Binary.java

---
 Easy/Add Binary.java | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/Easy/Add Binary.java b/Easy/Add Binary.java
index b51d82be..d35b471f 100644
--- a/Easy/Add Binary.java	
+++ b/Easy/Add Binary.java	
@@ -1,18 +1,19 @@
 class Solution {
   public String addBinary(String a, String b) {
-    int carry = 0;
     StringBuilder sb = new StringBuilder();
-    int idxA = a.length() - 1;
-    int idxB = b.length() - 1;
-    while (idxA >= 0 || idxB >= 0 || carry > 0) {
-      int temp = (
-        (idxA >= 0 ? Character.getNumericValue(a.charAt(idxA--)) : 0) + 
-        (idxB >= 0 ? Character.getNumericValue(b.charAt(idxB--)) : 0) + 
-        carry
-      );
-      carry = temp > 1 ? 1 : 0;
-      temp = temp > 1 ? (temp == 2 ? 0 : 1) : temp;
-      sb.append(temp);
+    int endIdxA = a.length() - 1;
+    int endIdxB = b.length() - 1;
+    int carry = 0;
+    while (endIdxA >= 0 || endIdxB >= 0 || carry > 0) {
+      int value = carry;
+      if (endIdxA >= 0) {
+        value += Character.getNumericValue(a.charAt(endIdxA--));
+      }
+      if (endIdxB >= 0) {
+        value += Character.getNumericValue(b.charAt(endIdxB--));
+      }
+      sb.append(value % 2);
+      carry = value / 2;
     }
     return sb.reverse().toString();
   }

From 9d4b55bc1e61451d0374d4b69f3fe05c09a2a705 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Aug 2022 16:23:09 -0700
Subject: [PATCH 1220/2175] Update Next Permutation.java

---
 Medium/Next Permutation.java | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/Medium/Next Permutation.java b/Medium/Next Permutation.java
index 9b554900..7b808969 100644
--- a/Medium/Next Permutation.java	
+++ b/Medium/Next Permutation.java	
@@ -1,10 +1,7 @@
 class Solution {
   public void nextPermutation(int[] nums) {
-    if (nums.length <= 1) {
-      return;
-    }
     int idx = nums.length - 2;
-    while (idx >= 0 && nums[idx] >= nums[idx + 1]) {
+    while (idx >= 0 && nums[idx + 1] <= nums[idx]) {
       idx--;
     }
     if (idx >= 0) {
@@ -14,16 +11,21 @@ public void nextPermutation(int[] nums) {
       }
       swap(nums, idx, endIdx);
     }
-    int startIdx = idx + 1;
+    reverse(nums, idx + 1);
+  }
+  
+  private void reverse(int[] nums, int startIdx) {
     int endIdx = nums.length - 1;
     while (startIdx < endIdx) {
-      swap(nums, startIdx++, endIdx--);
+      swap(nums, startIdx, endIdx);
+      startIdx++;
+      endIdx--;
     }
   }
   
-  private void swap(int[] nums, int idxOne, int idxTwo) {
-    int temp = nums[idxOne];
-    nums[idxOne] = nums[idxTwo];
-    nums[idxTwo] = temp;
+  private void swap(int[] nums, int i, int j) {
+    int temp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = temp;
   }
 }

From e9b785c13e1a8a4ee1cfb33811eb10d0d5a87db7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 12 Aug 2022 08:31:19 -0700
Subject: [PATCH 1221/2175] Update Lowest Common Ancestor of a Binary Search
 Tree.java

---
 ...t Common Ancestor of a Binary Search Tree.java | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/Easy/Lowest Common Ancestor of a Binary Search Tree.java b/Easy/Lowest Common Ancestor of a Binary Search Tree.java
index c4092475..d2a407b3 100644
--- a/Easy/Lowest Common Ancestor of a Binary Search Tree.java	
+++ b/Easy/Lowest Common Ancestor of a Binary Search Tree.java	
@@ -10,13 +10,16 @@
 
 class Solution {
   public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == p || root == q || 
-        (p.val > root.val && q.val < root.val) || 
-        (p.val < root.val && q.val > root.val)) {
+    if (root == null) {
       return root;
     }
-    return ((root.val > p.val && root.val > q.val) ? 
-            lowestCommonAncestor(root.left, p, q) : 
-            lowestCommonAncestor(root.right, p, q));
+    if (root == p || root == q) {
+      return root;
+    }
+    if ((root.val > p.val && root.val < q.val) || (root.val < p.val && root.val > q.val)) {
+      return root;
+    }
+    TreeNode left = lowestCommonAncestor(root.left, p, q);
+    return left == null ? lowestCommonAncestor(root.right, p, q) : left;
   }
 }

From eac3cc7656b9fab4181583d444583c015b05003a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 12 Aug 2022 16:15:53 -0700
Subject: [PATCH 1222/2175] Update Design Linked List.java

---
 Easy/Design Linked List.java | 164 ++++++++++++++++-------------------
 1 file changed, 73 insertions(+), 91 deletions(-)

diff --git a/Easy/Design Linked List.java b/Easy/Design Linked List.java
index 50533d0a..1f59ba54 100644
--- a/Easy/Design Linked List.java	
+++ b/Easy/Design Linked List.java	
@@ -1,106 +1,88 @@
 class MyLinkedList {
+  
+  private Node head;
+  private Node tail;
+  private int count;
+  
+  public MyLinkedList() {
+    this.head = new Node(-1);
+    this.tail = new Node(-1);
+    head.next = tail;
+    tail.prev = head;
+    this.count = 0;
+  }
 
-    /** Initialize your data structure here. */
-    Node head;
-    Node tail;
-    int count;
-    public MyLinkedList() {
-        head = new Node(-1);
-        tail = new Node(-1);
-        head.next = tail;
-        tail.prev = head;
-        count = 0;
-    }
-    
-    /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
-    public int get(int index) {
-        if (index < 0 || index >= count) {
-            return -1;
-        }
-        Node curr = head.next;
-        int idx = 0;
-        while (idx < index) {
-            idx++;
-            curr = curr.next;
-        }
-        return curr.val;
-    }
-    
-    /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
-    public void addAtHead(int val) {
-        Node newNode = new Node(val);
-        newNode.next = head.next;
-        newNode.prev = head;
-        head.next.prev = newNode;
-        head.next = newNode;
-        count++;
+  public int get(int index) {
+    Node node = getNode(index);
+    return node == null ? -1 : node.val;
+  }
+
+  public void addAtHead(int val) {
+    Node node = new Node(val);
+    Node nextNode = head.next;
+    node.next = nextNode;
+    node.prev = head;
+    nextNode.prev = node;
+    head.next = node;
+    count++;
+  }
+
+  public void addAtTail(int val) {
+    Node node = new Node(val);
+    Node prevNode = tail.prev;
+    node.next = tail;
+    tail.prev = node;
+    prevNode.next = node;
+    node.prev = prevNode;
+    count++;
+  }
+
+  public void addAtIndex(int index, int val) {
+    if (index == count) {
+      addAtTail(val);
+    } else if (index < count) {
+      Node nodeAtIndex = getNode(index);
+      Node prevNode = nodeAtIndex.prev;
+      Node node = new Node(val);
+      node.prev = prevNode;
+      prevNode.next = node;
+      node.next = nodeAtIndex;
+      nodeAtIndex.prev = node;
+      count++;
     }
-    
-    /** Append a node of value val to the last element of the linked list. */
-    public void addAtTail(int val) {
-        Node newNode = new Node(val);
-        newNode.prev = tail.prev;
-        newNode.next = tail;
-        tail.prev.next = newNode;
-        tail.prev = newNode;
-        count++;
+  }
+
+  public void deleteAtIndex(int index) {
+    Node node = getNode(index);
+    if (node != null) {
+      Node prevNode = node.prev;
+      Node nextNode = node.next;
+      prevNode.next = nextNode;
+      nextNode.prev = prevNode;
+      count--;
     }
-    
-    /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
-    public void addAtIndex(int index, int val) {
-        if (index < 0 || index > count) {
-            return;
-        }
-        if (index == 0) {
-            addAtHead(val);
-        }
-        else if (index == count) {
-            addAtTail(val);
-        }
-        else {
-            int idx = 0;
-            Node curr = head;
-            while (idx < index) {
-                idx++;
-                curr = curr.next;
-            }
-            Node newNode = new Node(val);
-            newNode.prev = curr;
-            newNode.next = curr.next;
-            curr.next.prev = newNode;
-            curr.next = newNode;
-            count++;
-        }
+  }
+  
+  private Node getNode(int index) {
+    if (index >= count) {
+      return null;
     }
-    
-    /** Delete the index-th node in the linked list, if the index is valid. */
-    public void deleteAtIndex(int index) {
-        if (index < 0 || index >= count) {
-            return;
-        }
-        int idx = 0;
-        Node curr = head;
-        while (idx < index) {
-            idx++;
-            curr = curr.next;
-        }
-        Node next = curr.next.next;
-        next.prev = curr;
-        curr.next = next;
-        count--;
+    Node curr = head.next;
+    for (int i = 0; i < index; i++) {
+      curr = curr.next;
     }
-}
-
-class Node {
+    return curr;
+  }
+  
+  private static class Node {
     int val;
     Node next;
     Node prev;
     
     public Node(int val) {
-        this.val = val;
-        next = null;
-        prev = null;
+      this.val = val;
     }
+  }
 }
 
 /**

From fd23e4cce68179b89083dbed113f3e1fb3d0c688 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 12 Aug 2022 17:53:30 -0700
Subject: [PATCH 1223/2175] Create Design Skiplist.java

---
 Hard/Design Skiplist.java | 86 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 Hard/Design Skiplist.java

diff --git a/Hard/Design Skiplist.java b/Hard/Design Skiplist.java
new file mode 100644
index 00000000..8554fcb7
--- /dev/null
+++ b/Hard/Design Skiplist.java	
@@ -0,0 +1,86 @@
+class Skiplist {
+  
+  private Node head;
+  private Random random;
+
+  public Skiplist() {
+    this.head = new Node(-1);
+    this.random = new Random();
+  }
+
+  public boolean search(int target) {
+    Node curr = head;
+    while (curr != null) {
+      while (curr.next != null && curr.next.val < target) {
+        curr = curr.next;
+      }
+      if (curr.next != null && curr.next.val == target) {
+        return true;
+      }
+      curr = curr.down;
+    }
+    return false;
+  }
+
+  public void add(int num) {
+    Stack<Node> stack = new Stack<>();
+    Node curr = head;
+    while (curr != null) {
+      while (curr.next != null && curr.next.val < num) {
+        curr = curr.next;
+      }
+      stack.push(curr);
+      curr = curr.down;
+    }
+    boolean newLevel = true;
+    Node downNode = null;
+    while (newLevel && !stack.isEmpty()) {
+      curr = stack.pop();
+      Node newNode = new Node(num);
+      newNode.next = curr.next;
+      newNode.down = downNode;
+      curr.next = newNode;
+      downNode = curr.next;
+      newLevel = random.nextDouble() < 0.5;
+    }
+    if (newLevel) {
+      Node prevHead = head;
+      head = new Node(-1);
+      head.down = prevHead;
+    }
+  }
+
+  public boolean erase(int num) {
+    Node curr = head;
+    boolean found = false;
+    while (curr != null) {
+      while (curr.next != null && curr.next.val < num) {
+        curr = curr.next;
+      }
+      if (curr.next != null && curr.next.val == num) {
+        found = true;
+        curr.next = curr.next.next;
+      }
+      curr = curr.down;
+    }
+    return found;
+  }
+  
+  private static class Node {
+    int val;
+    Node next;
+    Node down;
+    
+    public Node(int val) {
+      this.val = val;
+    }
+  }
+}
+
+/**
+ * Your Skiplist object will be instantiated and called as such:
+ * Skiplist obj = new Skiplist();
+ * boolean param_1 = obj.search(target);
+ * obj.add(num);
+ * boolean param_3 = obj.erase(num);
+ */

From e7b016adbd32e9d71fbe0a8162d6096f6a161aa6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 13 Aug 2022 08:20:36 -0700
Subject: [PATCH 1224/2175] Update Substring with Concatenation of All
 Words.java

---
 ...tring with Concatenation of All Words.java | 72 +++++++++++--------
 1 file changed, 43 insertions(+), 29 deletions(-)

diff --git a/Hard/Substring with Concatenation of All Words.java b/Hard/Substring with Concatenation of All Words.java
index 1af85664..5dcfd8bc 100644
--- a/Hard/Substring with Concatenation of All Words.java	
+++ b/Hard/Substring with Concatenation of All Words.java	
@@ -1,39 +1,53 @@
 class Solution {
   public List<Integer> findSubstring(String s, String[] words) {
-    if (s.length() == 0 || words.length == 0) {
-      return new ArrayList<>();
-    }
-    Map<String, Integer> wordFreqMap = new HashMap<>();
+    int numberOfWords = words.length;
+    int singleWordLength = words[0].length();
+    int totalSubstringLength = singleWordLength * numberOfWords;
+    Map<String, Integer> wordCount = new HashMap<>();
     for (String word : words) {
-      wordFreqMap.put(word, wordFreqMap.getOrDefault(word, 0) + 1);
+      wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
     }
-    int stringLength = s.length();
-    int wordCount = words.length;
-    int singleWordLength = words[0].length();
-    List<Integer> indices = new ArrayList<>();
-    for (int i = 0; i + singleWordLength * wordCount <= stringLength; i++) {
-      if (match(s, i, singleWordLength, wordFreqMap, wordCount)) {
-        indices.add(i);
-      }
+    List<Integer> result = new ArrayList<>();
+    for (int i = 0; i < singleWordLength; i++) {
+      slidingWindow(i, s, result, singleWordLength, totalSubstringLength, wordCount, numberOfWords);
     }
-    return indices;
+    return result;
   }
-  
-  private boolean match(String s, int start, int singleWordLength, Map<String, Integer> wordFreqMap, int wordCount) {
-    Map<String, Integer> currFreqMap = new HashMap<>();
-    for (int i = 0; i < wordCount; i++) {
-      String currWord = s.substring(start + i * singleWordLength, start + (i + 1) * singleWordLength);
-      Integer freq = wordFreqMap.get(currWord);
-      // Word not in required words
-      if (freq == null) { 
-        return false;
-      }
-      currFreqMap.put(currWord, currFreqMap.getOrDefault(currWord, 0) + 1);
-      // Word occurs more than the required count
-      if (currFreqMap.get(currWord) > freq) {
-        return false;
+
+  private void slidingWindow(int left, String s, List<Integer> answer, int singleWordLength,
+      int totalSubstringLength, Map<String, Integer> wordCount, int numberOfWords) {
+    Map<String, Integer> wordsFound = new HashMap<>();
+    int wordsUsed = 0;
+    boolean excessWord = false;
+    int n = s.length();
+    for (int right = left; right <= n - singleWordLength; right += singleWordLength) {
+      String currSubstring = s.substring(right, right + singleWordLength);
+      if (!wordCount.containsKey(currSubstring)) {
+        wordsFound.clear();
+        wordsUsed = 0;
+        excessWord = false;
+        left = right + singleWordLength;
+      } else {
+        while (right - left == totalSubstringLength || excessWord) {
+          String leftmostWord = s.substring(left, left + singleWordLength);
+          left += singleWordLength;
+          wordsFound.put(leftmostWord, wordsFound.get(leftmostWord) - 1);
+          if (wordsFound.get(leftmostWord) >= wordCount.get(leftmostWord)) {
+            excessWord = false;
+          } else {
+            wordsUsed--;
+          }
+        }
+        wordsFound.put(currSubstring, wordsFound.getOrDefault(currSubstring, 0) + 1);
+        if (wordsFound.get(currSubstring) <= wordCount.get(currSubstring)) {
+          wordsUsed++;
+        } else {
+          excessWord = true;
+        }
+        if (wordsUsed == numberOfWords && !excessWord) {
+          answer.add(left);
+        }
       }
     }
-    return true;
   }
 }

From 8c099b0b128dec14a2f209ddbf6e0b5331834897 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 14 Aug 2022 16:33:50 -0700
Subject: [PATCH 1225/2175] Create Node With Highest Edge Score.java

---
 Medium/Node With Highest Edge Score.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Node With Highest Edge Score.java

diff --git a/Medium/Node With Highest Edge Score.java b/Medium/Node With Highest Edge Score.java
new file mode 100644
index 00000000..9154bb2f
--- /dev/null
+++ b/Medium/Node With Highest Edge Score.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int edgeScore(int[] edges) {
+    Map<Integer, Integer> map = new HashMap<>();
+    int highestScore = 0;
+    int highestScoreCandidate = Integer.MAX_VALUE;
+    for (int i = 0; i < edges.length; i++) {
+      map.put(edges[i], map.getOrDefault(edges[i], 0) + i);
+      if (highestScore <= map.get(edges[i])) {
+        if (highestScore < map.get(edges[i])) {
+          highestScore = map.get(edges[i]);
+          highestScoreCandidate = edges[i];
+        } else if (highestScore == map.get(edges[i]) && highestScoreCandidate > edges[i]) {
+          highestScoreCandidate = edges[i];
+        }
+      }
+    }
+    return highestScoreCandidate;
+  }
+}

From 93d7ac2a3780e2ab9e4c23b6e2523cb94b00c06f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 Aug 2022 08:16:44 -0700
Subject: [PATCH 1226/2175] Update Roman to Integer.java

---
 Easy/Roman to Integer.java | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/Easy/Roman to Integer.java b/Easy/Roman to Integer.java
index 7b269b0b..c0c047ee 100644
--- a/Easy/Roman to Integer.java	
+++ b/Easy/Roman to Integer.java	
@@ -1,25 +1,23 @@
 class Solution {
+  
   public int romanToInt(String s) {
-    String[] keys = {"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"};
-    int[] values = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
+    String[] strings = {"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"};
+    int[] value = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
     Map<String, Integer> map = new HashMap<>();
-    for (int i = 0; i < keys.length; i++) {
-      map.put(keys[i], values[i]);
-    }
-    int val = 0;
+    for (int i = 0; i < strings.length; i++) {
+      map.put(strings[i], value[i]);
+    } 
     int idx = 0;
-    int n = s.length();
-    while (idx < n) {
-      char c = s.charAt(idx);
-      if (idx + 1 < n && map.containsKey(s.substring(idx, idx + 2))) {
-        val += map.get(s.substring(idx, idx + 2));
+    int num = 0;
+    while (idx < s.length()) {
+      if (idx + 1 < s.length() && map.containsKey(s.substring(idx, idx + 2))) {
+        num += map.get(s.substring(idx, idx + 2));
         idx += 2;
-      }
-      else {
-        val += map.get(String.valueOf(c));
+      } else {
+        num += map.get(s.substring(idx, idx + 1));
         idx++;
       }
     }
-    return val;
+    return num;
   }
 }

From 51334398e7a7692d7e790f5a7885870e9f0e9938 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 Aug 2022 08:29:18 -0700
Subject: [PATCH 1227/2175] Update Dot Product of Two Sparse Vectors.java

---
 Medium/Dot Product of Two Sparse Vectors.java | 29 ++++++++++++-------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/Medium/Dot Product of Two Sparse Vectors.java b/Medium/Dot Product of Two Sparse Vectors.java
index 912d250e..824c407f 100644
--- a/Medium/Dot Product of Two Sparse Vectors.java	
+++ b/Medium/Dot Product of Two Sparse Vectors.java	
@@ -1,29 +1,36 @@
 class SparseVector {
-
-  private Map<Integer, Integer> map;
+  
+  private Map<Integer, Integer> nonZeroRowMap;
 
   SparseVector(int[] nums) {
-    this.map = new HashMap<>();
+    this.nonZeroRowMap = new HashMap<>();
     for (int i = 0; i < nums.length; i++) {
       if (nums[i] != 0) {
-        this.map.put(i, nums[i]);
+        nonZeroRowMap.put(i, nums[i]);
       }
     }
   }
 
-  // Return the dotProduct of two sparse vectors
+// Return the dotProduct of two sparse vectors
   public int dotProduct(SparseVector vec) {
-    return vec.map.size() > this.map.size() ? dotProductHelper(this.map, vec.map)
-        : dotProductHelper(vec.map, this.map);
+    Map<Integer, Integer> vecNonZeroRowMap = vec.getNonZeroRowMap();
+    return this.nonZeroRowMap.size() < vecNonZeroRowMap.size() ? dotProductHelper(this.nonZeroRowMap, vecNonZeroRowMap) : dotProductHelper(vecNonZeroRowMap, this.nonZeroRowMap);
   }
-
+  
   private int dotProductHelper(Map<Integer, Integer> mapOne, Map<Integer, Integer> mapTwo) {
     int product = 0;
     for (Integer key : mapOne.keySet()) {
-      if (mapTwo.containsKey(key)) {
-        product += mapOne.get(key) * mapTwo.get(key);
-      }
+      product += mapOne.get(key) * mapTwo.getOrDefault(key, 0);
     }
     return product;
   }
+  
+  public Map<Integer, Integer> getNonZeroRowMap() {
+    return new HashMap<>(nonZeroRowMap);
+  }
 }
+
+// Your SparseVector object will be instantiated and called as such:
+// SparseVector v1 = new SparseVector(nums1);
+// SparseVector v2 = new SparseVector(nums2);
+// int ans = v1.dotProduct(v2);

From b74a7649e064e491f06d0a2fcee1d960afe4b7ab Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 Aug 2022 15:05:29 -0700
Subject: [PATCH 1228/2175] Update Pairs of Songs With Total Durations
 Divisible by 60.java

---
 Easy/Pairs of Songs With Total Durations Divisible by 60.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Easy/Pairs of Songs With Total Durations Divisible by 60.java b/Easy/Pairs of Songs With Total Durations Divisible by 60.java
index 5bf90390..20ee84c3 100644
--- a/Easy/Pairs of Songs With Total Durations Divisible by 60.java	
+++ b/Easy/Pairs of Songs With Total Durations Divisible by 60.java	
@@ -3,9 +3,7 @@ public int numPairsDivisibleBy60(int[] time) {
     Map<Integer, Integer> map = new HashMap<>();
     int count = 0;
     for (int t : time) {
-      if (map.containsKey(((60 - t % 60)) % 60)) {
-        count += map.get((60 - t % 60) % 60);
-      }
+      count += map.getOrDefault((60 - t % 60) % 60, 0);
       map.put(t % 60, map.getOrDefault(t % 60, 0) + 1);
     }
     return count;

From 3dc6e000c59d36fbac19c749803a101cd030d371 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 Aug 2022 17:49:42 -0700
Subject: [PATCH 1229/2175] Update First Unique Character in a String.java

---
 Easy/First Unique Character in a String.java | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/Easy/First Unique Character in a String.java b/Easy/First Unique Character in a String.java
index 64bacbda..1659cbb5 100644
--- a/Easy/First Unique Character in a String.java	
+++ b/Easy/First Unique Character in a String.java	
@@ -1,16 +1,11 @@
 class Solution {
   public int firstUniqChar(String s) {
-    int[] arr = new int[26];
+    int[] count = new int[26];
     for (char c : s.toCharArray()) {
-      if (arr[c - 'a'] != 0) {
-        arr[c - 'a'] = -1;
-      }
-      else {
-        arr[c - 'a'] = 1;
-      }
+      count[c - 'a']++;
     }
     for (int i = 0; i < s.length(); i++) {
-      if (arr[s.charAt(i) - 'a'] == 1) {
+      if (count[s.charAt(i) - 'a'] == 1) {
         return i;
       }
     }

From 918e529b57b53dfe6d5195357f6327e30648f61a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 18 Aug 2022 07:26:12 -0700
Subject: [PATCH 1230/2175] Update Reduce Array Size to The Half.java

---
 Medium/Reduce Array Size to The Half.java | 33 +++++++++++++++--------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/Medium/Reduce Array Size to The Half.java b/Medium/Reduce Array Size to The Half.java
index de698435..82572571 100644
--- a/Medium/Reduce Array Size to The Half.java	
+++ b/Medium/Reduce Array Size to The Half.java	
@@ -1,16 +1,27 @@
 class Solution {
   public int minSetSize(int[] arr) {
-    Map<Integer, Long> frequencyMap = Arrays.stream(arr).boxed()
-        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
-    int halfSize = arr.length / 2;
-    PriorityQueue<Integer> pq = new PriorityQueue<>(
-        (o1, o2) -> (int) (frequencyMap.get(o2) - frequencyMap.get(o1)));
-    pq.addAll(frequencyMap.keySet());
-    int counter = 0;
-    while (!pq.isEmpty() && halfSize > 0) {
-      halfSize -= frequencyMap.get(pq.poll());
-      counter++;
+    Map<Integer, Integer> map = new HashMap<>();
+    int maxCount = 0;
+    for (int num : arr) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+      maxCount = Math.max(maxCount, map.get(num));
     }
-    return counter;
+    int[] bucket = new int[maxCount + 1];
+    for (int count : map.values()) {
+      bucket[count]++;
+    }
+    int n = arr.length;
+    int setSize = 0;
+    int bucketIdx = bucket.length - 1;
+    while (n > arr.length / 2) {
+      if (bucket[bucketIdx] > 0) {
+        setSize++;
+        n -= bucketIdx;
+        bucket[bucketIdx]--;
+      } else {
+        bucketIdx--;
+      }
+    }
+    return setSize;
   }
 }

From 2404017ad2f58287de538d3993015afab38cddf4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 18 Aug 2022 14:42:41 -0700
Subject: [PATCH 1231/2175] Create Dice Roll Simulation.java

---
 Hard/Dice Roll Simulation.java | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Hard/Dice Roll Simulation.java

diff --git a/Hard/Dice Roll Simulation.java b/Hard/Dice Roll Simulation.java
new file mode 100644
index 00000000..47ba0ce5
--- /dev/null
+++ b/Hard/Dice Roll Simulation.java	
@@ -0,0 +1,29 @@
+class Solution {
+  private final long MOD = (long) Math.pow(10, 9) + 7;
+  
+  public int dieSimulator(int n, int[] rollMax) {
+    long[][] dp = new long[n][7];
+    for(int i = 0; i < 6; i++) {
+      dp[0][i] = 1;
+    }
+    dp[0][6] = 6;
+    for(int i = 1; i < n; i++) {
+      long sum = 0;
+      for(int j = 0; j < 6; j++) {
+        dp[i][j] = dp[i - 1][6];
+        if (i - rollMax[j] < 0) {
+          sum = (sum + dp[i][j]) % MOD;
+        } else {
+          if (i - rollMax[j] - 1 >= 0) { 
+            dp[i][j] = (dp[i][j] - (dp[i - rollMax[j] - 1][6] - dp[i - rollMax[j] - 1][j])) % MOD + MOD;
+          } else {
+            dp[i][j] = (dp[i][j] - 1) % MOD;
+          }
+          sum = (sum + dp[i][j]) % MOD;
+        }
+      }
+      dp[i][6] = sum;
+    }
+    return (int) (dp[n - 1][6]);
+  }
+}

From 7428c07b60063b97c197e62bed570f140b436c3b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 18 Aug 2022 14:44:51 -0700
Subject: [PATCH 1232/2175] Update Matrix Diagonal Sum.java

---
 Easy/Matrix Diagonal Sum.java | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

diff --git a/Easy/Matrix Diagonal Sum.java b/Easy/Matrix Diagonal Sum.java
index 772421b7..32e2a58f 100644
--- a/Easy/Matrix Diagonal Sum.java	
+++ b/Easy/Matrix Diagonal Sum.java	
@@ -1,21 +1,10 @@
 class Solution {
   public int diagonalSum(int[][] mat) {
+    int n = mat.length;
     int sum = 0;
-    // Left -> Right Diagonal
-    for (int i = 0; i < mat.length; i++) {
-      sum += mat[i][i];
+    for (int i = 0; i < n; i++) {
+      sum += mat[i][i] + mat[i][n - i - 1];
     }
-    // Right -> Left Diagonal
-    int rowIdx = 0;
-    int colIdx = mat[0].length - 1;
-    while (rowIdx < mat.length) {
-      // Check to remove intersecting element in both diagonals
-      if (rowIdx != colIdx) {
-        sum += mat[rowIdx][colIdx];
-      }
-      rowIdx++;
-      colIdx--;
-    }
-    return sum;
+    return sum - (n % 2 == 0 ? 0 : mat[n / 2][n / 2]);
   }
 }

From 4e7200421ca8715b00e1475729ec99961e89d50e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 18 Aug 2022 15:13:11 -0700
Subject: [PATCH 1233/2175] Update Count Hills and Valleys in an Array.java

---
 Easy/Count Hills and Valleys in an Array.java | 20 +++++++------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/Easy/Count Hills and Valleys in an Array.java b/Easy/Count Hills and Valleys in an Array.java
index 750cc964..40372dfd 100644
--- a/Easy/Count Hills and Valleys in an Array.java	
+++ b/Easy/Count Hills and Valleys in an Array.java	
@@ -1,19 +1,13 @@
 class Solution {
   public int countHillValley(int[] nums) {
-    List<Integer> list = new ArrayList<>();
-    list.add(nums[0]);
-    for (int i = 1; i < nums.length; i++) {
-      if (nums[i] != nums[i - 1]) {
-        list.add(nums[i]);
+    int count = 0;
+    int left = nums[0];
+    for (int i = 1; i < nums.length - 1; i++) {
+      if ((left < nums[i] && nums[i] > nums[i + 1]) || (left > nums[i] && nums[i] < nums[i + 1])) {
+        left = nums[i];
+        count++;
       }
     }
-    int hillsAndVallies = 0;
-    for (int i = 1; i < list.size() - 1; i++) {
-      if ((list.get(i) < list.get(i - 1) && list.get(i) < list.get(i + 1)) || 
-          (list.get(i) > list.get(i - 1) && list.get(i) > list.get(i + 1))) {
-        hillsAndVallies++;
-      }
-    }
-    return hillsAndVallies;
+    return count;
   }
 }

From 7d55e02fa39b3753b0a9043e7d26454381d37835 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 19 Aug 2022 10:27:38 -0700
Subject: [PATCH 1234/2175] Update Split Array into Consecutive
 Subsequences.java

---
 ...t Array into Consecutive Subsequences.java | 39 +++++++++++--------
 1 file changed, 22 insertions(+), 17 deletions(-)

diff --git a/Medium/Split Array into Consecutive Subsequences.java b/Medium/Split Array into Consecutive Subsequences.java
index f31de956..17425bd5 100644
--- a/Medium/Split Array into Consecutive Subsequences.java	
+++ b/Medium/Split Array into Consecutive Subsequences.java	
@@ -1,28 +1,33 @@
 class Solution {
   public boolean isPossible(int[] nums) {
-    Map<Integer, Integer> map = new HashMap<>();
-    Map<Integer, Integer> appendMap = new HashMap<>();
+    PriorityQueue<int[]> pq = new PriorityQueue<>((int[] o1, int[] o2) -> {
+      if (o1[1] == o2[1]) {
+        return (o1[1] - o1[0]) - (o2[1] - o2[0]);
+      } 
+      return o1[1] - o2[1];
+    });
     for (int num : nums) {
-      map.put(num, map.getOrDefault(num, 0) + 1);
-    }
-    for (int i : nums) {
-      if (map.get(i) == 0) {
-        continue;
-      }
-      else if (appendMap.getOrDefault(i, 0) > 0) {
-        appendMap.put(i, appendMap.get(i) - 1);
-        appendMap.put(i + 1, appendMap.getOrDefault(i + 1, 0) + 1);
+      while (!pq.isEmpty() && pq.peek()[1] + 1 < num) {
+        if (!isValidSubsequence(pq.poll())) {
+          return false;
+        }
       }
-      else if (map.getOrDefault(i + 1, 0) > 0 && map.getOrDefault(i + 2, 0) > 0) {
-        map.put(i + 1, map.get(i + 1) - 1);
-        map.put(i + 2, map.get(i + 2) - 1);
-        appendMap.put(i + 3, appendMap.getOrDefault(i + 3, 0) + 1);
+      if (pq.isEmpty() || pq.peek()[1] == num) {
+        pq.add(new int[]{num, num});
+      } else {
+        int[] subsequence = pq.poll();
+        pq.add(new int[]{subsequence[0], num});
       }
-      else {
+    }
+    while (!pq.isEmpty()) {
+      if (!isValidSubsequence(pq.poll())) {
         return false;
       }
-      map.put(i, map.get(i) - 1);
     }
     return true;
   }
+  
+  private boolean isValidSubsequence(int[] subsequence) {
+    return subsequence[1] - subsequence[0] + 1 >= 3;
+  }
 }

From fec4465ed395b80e38430a013f9a1208e9442b2c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Aug 2022 10:03:26 -0700
Subject: [PATCH 1235/2175] Create Minimum Number of Refueling Stops.java

---
 Hard/Minimum Number of Refueling Stops.java | 27 +++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Hard/Minimum Number of Refueling Stops.java

diff --git a/Hard/Minimum Number of Refueling Stops.java b/Hard/Minimum Number of Refueling Stops.java
new file mode 100644
index 00000000..217cbe08
--- /dev/null
+++ b/Hard/Minimum Number of Refueling Stops.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public int minRefuelStops(int target, int startFuel, int[][] stations) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+    int result = 0;
+    int prev = 0;
+    for (int[] station : stations) {
+      int location = station[0];
+      int capacity = station[1];
+      startFuel -= location - prev;
+      while (!pq.isEmpty() && startFuel < 0) {
+        startFuel += pq.poll();
+        result++;
+      }
+      if (startFuel < 0) {
+        return -1;
+      }
+      pq.add(capacity);
+      prev = location;
+    }
+    startFuel -= target - prev;
+    while (!pq.isEmpty() && startFuel < 0) {
+      startFuel += pq.poll();
+      result++;
+    }
+    return startFuel < 0 ? -1 : result;
+  }
+}

From 1c719595ca978e9715c2ed9562d018b5a81ab662 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Aug 2022 10:18:44 -0700
Subject: [PATCH 1236/2175] Create Minimum Recolors to Get K Consecutive Black
 Blocks.java

---
 ...olors to Get K Consecutive Black Blocks.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Minimum Recolors to Get K Consecutive Black Blocks.java

diff --git a/Easy/Minimum Recolors to Get K Consecutive Black Blocks.java b/Easy/Minimum Recolors to Get K Consecutive Black Blocks.java
new file mode 100644
index 00000000..596297cd
--- /dev/null
+++ b/Easy/Minimum Recolors to Get K Consecutive Black Blocks.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public int minimumRecolors(String blocks, int k) {
+    int minRecolors = Integer.MAX_VALUE;
+    int blackBlockCount = 0;
+    for (int i = 0; i < k; i++) {
+      blackBlockCount += blocks.charAt(i) == 'W' ? 0 : 1;
+    }
+    int startIdx = 0;
+    for (int i = k; i < blocks.length(); i++) {
+      minRecolors = Math.min(minRecolors, k - blackBlockCount);
+      blackBlockCount += blocks.charAt(startIdx++) == 'W' ? 0 : -1;
+      blackBlockCount += blocks.charAt(i) == 'W' ? 0 : 1;
+    }
+    minRecolors = Math.min(minRecolors, k - blackBlockCount);
+    return minRecolors;
+  }
+}

From 81e2b426446d1f2e9d23ff43ba30805766a2ce8b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Aug 2022 14:21:33 -0700
Subject: [PATCH 1237/2175] Update Sparse Matrix Multiplication.java

---
 Medium/Sparse Matrix Multiplication.java | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/Medium/Sparse Matrix Multiplication.java b/Medium/Sparse Matrix Multiplication.java
index e1e20566..d612b920 100644
--- a/Medium/Sparse Matrix Multiplication.java	
+++ b/Medium/Sparse Matrix Multiplication.java	
@@ -1,20 +1,15 @@
 class Solution {
-  public int[][] multiply(int[][] A, int[][] B) {
-    int m = A.length;
-    int n = A[0].length;
-    int nB = B[0].length;
-    int[][] C = new int[m][nB];
-    for(int i = 0; i < m; i++) {
-      for(int k = 0; k < n; k++) {
-        if (A[i][k] != 0) {
-          for (int j = 0; j < nB; j++) {
-            if (B[k][j] != 0) {
-              C[i][j] += A[i][k] * B[k][j];
-            }
+  public int[][] multiply(int[][] mat1, int[][] mat2) {
+    int[][] result = new int[mat1.length][mat2[0].length];
+    for (int i = 0; i < mat1.length; i++) {
+      for (int j = 0; j < mat1[0].length; j++) {
+        if (mat1[i][j] != 0) {
+          for (int k = 0; k < mat2[0].length; k++) {
+            result[i][k] += mat1[i][j] * mat2[j][k];
           }
         }
       }
     }
-    return C;   
+    return result;
   }
 }

From 364a4aac6dc5fc0ecdd2d4c64f92868797f53869 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Aug 2022 14:34:27 -0700
Subject: [PATCH 1238/2175] Update Design Hit Counter.java

---
 Medium/Design Hit Counter.java | 51 ++++++++++++++--------------------
 1 file changed, 21 insertions(+), 30 deletions(-)

diff --git a/Medium/Design Hit Counter.java b/Medium/Design Hit Counter.java
index 374d33c3..c241a419 100644
--- a/Medium/Design Hit Counter.java	
+++ b/Medium/Design Hit Counter.java	
@@ -1,37 +1,28 @@
 class HitCounter {
+  
+  private Deque<int[]> record;
+  private int count;
+  
+  public HitCounter() {
+    this.record = new LinkedList<>();
+    this.count = 0;
+  }
 
-    /** Initialize your data structure here. */
-    int[] times;
-    int[] hits;
-    public HitCounter() {
-        times = new int[300];
-        hits = new int[300];
+  public void hit(int timestamp) {
+    if (!record.isEmpty() && record.getLast()[0] == timestamp) {
+      record.getLast()[1]++;
+    } else {
+      record.add(new int[]{timestamp, 1});
     }
-    
-    /** Record a hit.
-        @param timestamp - The current timestamp (in seconds granularity). */
-    public void hit(int timestamp) {
-        int idx = timestamp % 300;
-        if (times[idx] != timestamp) {
-            times[idx] = timestamp;
-            hits[idx] = 1;
-        }
-        else {
-            hits[idx]++;
-        }
-    }
-    
-    /** Return the number of hits in the past 5 minutes.
-        @param timestamp - The current timestamp (in seconds granularity). */
-    public int getHits(int timestamp) {
-        int totalCount = 0;
-        for (int i = 0; i < 300; i++) {
-            if (timestamp - times[i] < 300) {
-                totalCount += hits[i];
-            }
-        }
-        return totalCount;
+    this.count++;
+  }
+
+  public int getHits(int timestamp) {
+    while (!record.isEmpty() && timestamp - record.getFirst()[0] >= 300) {
+      this.count -= record.removeFirst()[1];
     }
+    return this.count;
+  }
 }
 
 /**

From 92004edcae505e4fdee250605ea49bc45a9683c8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Aug 2022 15:53:14 -0700
Subject: [PATCH 1239/2175] Create Time Needed to Rearrange a Binary
 String.java

---
 .../Time Needed to Rearrange a Binary String.java   | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Time Needed to Rearrange a Binary String.java

diff --git a/Medium/Time Needed to Rearrange a Binary String.java b/Medium/Time Needed to Rearrange a Binary String.java
new file mode 100644
index 00000000..f9c4dcf5
--- /dev/null
+++ b/Medium/Time Needed to Rearrange a Binary String.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int secondsToRemoveOccurrences(String s) {
+    int time = 0;
+    int zeros = 0;
+    for (int i = 0; i < s.length(); i++) {
+      zeros += s.charAt(i) == '0' ? 1 : 0;
+      if (s.charAt(i) == '1' && zeros > 0) {
+        time = Math.max(time + 1, zeros);
+      }
+    }
+    return time;
+  }
+}

From 829b6444d2d89785aaf4d90248c0f309406d18a0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Aug 2022 10:46:56 -0700
Subject: [PATCH 1240/2175] Create Stamping The Sequence.java

---
 Hard/Stamping The Sequence.java | 50 +++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 Hard/Stamping The Sequence.java

diff --git a/Hard/Stamping The Sequence.java b/Hard/Stamping The Sequence.java
new file mode 100644
index 00000000..1d472157
--- /dev/null
+++ b/Hard/Stamping The Sequence.java	
@@ -0,0 +1,50 @@
+class Solution {
+  public int[] movesToStamp(String stamp, String target) {
+    char[] stampLetters = stamp.toCharArray();
+    char[] targetLetters = target.toCharArray();
+    List<Integer> result = new ArrayList<>();
+    boolean[] visited = new boolean[target.length()];
+    int count = 0;
+    while (count < target.length()) {
+      boolean replace = false;
+      for (int i = 0; i <= target.length() - stamp.length(); i++) {
+        if (!visited[i] && isReplacePossible(stampLetters, targetLetters, i)) {
+          count = performStamping(targetLetters, i, stamp.length(), count);
+          replace = true;
+          visited[i] = true;
+          result.add(i);
+          if (count == targetLetters.length) {
+            break;
+          }
+        }
+      }
+      if (!replace) {
+        return new int[0];   
+      }
+    }
+    int[] resArray = new int[result.size()];
+    for (int i = 0; i < result.size(); i++) {
+      resArray[i] = result.get(result.size() - i - 1);
+    }
+    return resArray;
+  }
+  
+  private boolean isReplacePossible(char[] stampLetters, char[] targetLetters, int idx) {
+    for (int i = 0; i < stampLetters.length; i++) {
+      if (targetLetters[i + idx] != '*' && targetLetters[i + idx] != stampLetters[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+    
+  private int performStamping(char[] targetLetters, int idx, int stampLength, int count) {
+    for (int i = 0; i < stampLength; i++) {
+      if (targetLetters[i + idx] != '*') {
+        targetLetters[i + idx] = '*';
+        count++;
+      }
+    }
+    return count;
+  }
+}

From f50d9caff927433439c07ca1468b4e0a1e54ee65 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Aug 2022 11:18:09 -0700
Subject: [PATCH 1241/2175] Create Minimum Hours of Training to Win a
 Competition.java

---
 ...um Hours of Training to Win a Competition.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Minimum Hours of Training to Win a Competition.java

diff --git a/Easy/Minimum Hours of Training to Win a Competition.java b/Easy/Minimum Hours of Training to Win a Competition.java
new file mode 100644
index 00000000..1e9f0c90
--- /dev/null
+++ b/Easy/Minimum Hours of Training to Win a Competition.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int minNumberOfHours(int initialEnergy, int initialExperience, int[] energy, int[] experience) {
+    int totalEnergy = 0;
+    int experienceDeficit = 0;
+    for (int i = 0; i < energy.length; i++) {
+      totalEnergy += energy[i];
+      if (initialExperience <= experience[i]) {
+        experienceDeficit += experience[i] - initialExperience + 1;
+        initialExperience = experience[i] + 1;
+      }
+      initialExperience += experience[i];
+    }
+    return experienceDeficit + (totalEnergy >= initialEnergy ? totalEnergy - initialEnergy + 1 : 0);
+  }
+}

From c0b2d46db1470d56ea6bfc73aebfc5e4742331b9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Aug 2022 18:14:54 -0700
Subject: [PATCH 1242/2175] Update and rename Power of four.java to Power of
 Four.java

---
 Easy/Power of Four.java | 19 +++++++++++++++++++
 Easy/Power of four.java | 20 --------------------
 2 files changed, 19 insertions(+), 20 deletions(-)
 create mode 100644 Easy/Power of Four.java
 delete mode 100644 Easy/Power of four.java

diff --git a/Easy/Power of Four.java b/Easy/Power of Four.java
new file mode 100644
index 00000000..18dd30c1
--- /dev/null
+++ b/Easy/Power of Four.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public boolean isPowerOfFour(int n) {
+    long left = 0;
+    long right = n / 2 + 1;
+    while (left <= right) {
+      long mid = (left + right) / 2;
+      long pow = (long) (Math.pow(4, mid));
+      if (pow == ((long) n)) {
+        return true;
+      }
+      if (pow > ((long) n)) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    }
+    return false;
+  }
+}
diff --git a/Easy/Power of four.java b/Easy/Power of four.java
deleted file mode 100644
index 254d5097..00000000
--- a/Easy/Power of four.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-  public boolean isPowerOfFour(int num) {
-    long start = 0;
-    long end = num / 4;
-    while (start <= end) {
-      long mid = (start + end) / 2;
-      long pow = (long) Math.pow(4, mid);
-      if (pow == (long) num) {
-        return true;
-      }
-      else if (pow > (long) num) {
-        end = mid - 1;
-      }
-      else {
-        start = mid + 1;
-      }
-    }
-    return false;
-  }
-}

From 421d275cb70ad228dcbab21e2a07943cbdc92746 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Aug 2022 11:35:45 -0700
Subject: [PATCH 1243/2175] Update Build Array from Permutation.java

---
 Easy/Build Array from Permutation.java | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/Easy/Build Array from Permutation.java b/Easy/Build Array from Permutation.java
index 88119f3d..6a2a6dec 100644
--- a/Easy/Build Array from Permutation.java	
+++ b/Easy/Build Array from Permutation.java	
@@ -1,9 +1,12 @@
 class Solution {
   public int[] buildArray(int[] nums) {
-    int[] ans = new int[nums.length];
-    for (int i = 0; i < nums.length; i++) {
-      ans[i] = nums[nums[i]];
+    int n = nums.length;
+    for (int i = 0; i < n; i++) {
+      nums[i] = nums[i] + n * (nums[nums[i]] % n);
     }
-    return ans;
+    for (int i = 0; i < n; i++) {
+      nums[i] = nums[i] / n;
+    }
+    return nums;
   }
 }

From 08a68b5c1e708f1dcf80d665fa6ec0e1dce5e690 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Aug 2022 12:05:44 -0700
Subject: [PATCH 1244/2175] Update Kids With the Greatest Number of
 Candies.java

---
 Easy/Kids With the Greatest Number of Candies.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Easy/Kids With the Greatest Number of Candies.java b/Easy/Kids With the Greatest Number of Candies.java
index 69e60fb2..79789d90 100644
--- a/Easy/Kids With the Greatest Number of Candies.java	
+++ b/Easy/Kids With the Greatest Number of Candies.java	
@@ -1,13 +1,13 @@
 class Solution {
   public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
-    int max = Integer.MIN_VALUE;
+    int maxCandyCount = 0;
     for (int candy : candies) {
-      max = Math.max(max, candy);
+      maxCandyCount = Math.max(maxCandyCount, candy);
     }
-    List<Boolean> ans = new ArrayList<>();
-    for (int i = 0; i < candies.length; i++) {
-      ans.add((candies[i] + extraCandies) >= max);
+    List<Boolean> result = new ArrayList<>();
+    for (int candy : candies) {
+      result.add((candy + extraCandies) >= maxCandyCount);
     }
-    return ans;
+    return result;
   }
 }

From 9a98191ac2ad61e9276f359abebf080d7d3c9c3d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Aug 2022 12:40:12 -0700
Subject: [PATCH 1245/2175] Update Binary Tree Longest Consecutive Sequence
 II.java

---
 ... Tree Longest Consecutive Sequence II.java | 73 +++++++++----------
 1 file changed, 36 insertions(+), 37 deletions(-)

diff --git a/Medium/Binary Tree Longest Consecutive Sequence II.java b/Medium/Binary Tree Longest Consecutive Sequence II.java
index db766780..41e04cba 100644
--- a/Medium/Binary Tree Longest Consecutive Sequence II.java	
+++ b/Medium/Binary Tree Longest Consecutive Sequence II.java	
@@ -4,46 +4,45 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int longestConsecutive(TreeNode root) {   
-        int[] ans = new int[1];
-        helper(root, ans);
-        return ans[0];
+  public int longestConsecutive(TreeNode root) {
+    int[] result = {0};
+    helper(root, result);
+    return result[0];
+  }
+  
+  private int[] helper(TreeNode root, int[] result) {
+    if (root == null) {
+      return new int[]{0, 0};
     }
-    
-    private int[] helper(TreeNode root, int[] ans) {
-        if (root == null) {
-            return new int[]{0,0};
-        }
-        
-        int increase = 1;
-        int decrease = 1;
-        
-        if (root.left != null) {
-            int[] left = helper(root.left, ans);
-            if (root.val == root.left.val - 1) {
-                increase = left[0] + 1;
-            }
-            if (root.val == root.left.val + 1) {
-                decrease = left[1] + 1;
-            }
-        }
-        
-        if (root.right != null) {
-            int[] right = helper(root.right, ans);
-            if (root.val == root.right.val - 1) {
-                increase = Math.max(right[0] + 1, increase);
-            }
-            if (root.val == root.right.val + 1) {
-                decrease = Math.max(right[1] + 1, decrease);
-            }
-        }
-        
-        ans[0] = Math.max(ans[0], increase + decrease - 1);
-        
-        return new int[]{increase, decrease};
+    int increment = 1;
+    int decrement = 1;
+    if (root.left != null) {
+      int[] left = helper(root.left, result);
+      if (root.val == root.left.val + 1) {
+        decrement = left[1] + 1;
+      } else if (root.val == root.left.val - 1) {
+        increment = left[0] + 1;
+      }
     }
+    if (root.right != null) {
+      int[] right = helper(root.right, result);
+      if (root.val == root.right.val + 1) {
+        decrement = Math.max(decrement, right[1] + 1);
+      } else if (root.val == root.right.val - 1) {
+        increment = Math.max(increment, right[0] + 1);
+      }
+    }
+    result[0] = Math.max(result[0], increment + decrement - 1);
+    return new int[]{increment, decrement};
+  }
 }

From 93dc6a018d6dc02ed056d84eb5af16d33a41d07e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Aug 2022 12:49:30 -0700
Subject: [PATCH 1246/2175] Update Find Target Indices After Sorting Array.java

---
 .../Find Target Indices After Sorting Array.java | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/Easy/Find Target Indices After Sorting Array.java b/Easy/Find Target Indices After Sorting Array.java
index f0776eba..d000c8ad 100644
--- a/Easy/Find Target Indices After Sorting Array.java	
+++ b/Easy/Find Target Indices After Sorting Array.java	
@@ -3,17 +3,13 @@ public List<Integer> targetIndices(int[] nums, int target) {
     int count = 0;
     int lessThanCount = 0;
     for (int num : nums) {
-      if (num == target) {
-        count++;
-      }
-      if (num < target) {
-        lessThanCount++;
-      }
+      count += num == target ? 1 : 0;
+      lessThanCount += num < target ? 1 : 0;
     }
-    List<Integer> indices = new ArrayList<>();
-    for (int i = 0; i < count; i++) {
-      indices.add(lessThanCount + i);
+    List<Integer> result = new ArrayList<>();
+    while (count-- > 0) {
+      result.add(lessThanCount++);
     }
-    return indices;
+    return result;
   }
 }

From d34c42b0630d49bcb2af3cbecc82f696ba6cb27d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Aug 2022 16:41:47 -0700
Subject: [PATCH 1247/2175] Update Unique Number of Occurrences.java

---
 Easy/Unique Number of Occurrences.java | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/Easy/Unique Number of Occurrences.java b/Easy/Unique Number of Occurrences.java
index fb61d166..b442d51c 100644
--- a/Easy/Unique Number of Occurrences.java	
+++ b/Easy/Unique Number of Occurrences.java	
@@ -1,10 +1,9 @@
 class Solution {
-    public boolean uniqueOccurrences(int[] arr) {
-        Map<Integer, Integer> map = new HashMap<>();
-        for (int num : arr) {
-            map.put(num, map.getOrDefault(num, 0) + 1);
-        }
-        Set<Integer> set = new HashSet<>(map.values());
-        return map.size() == set.size();
+  public boolean uniqueOccurrences(int[] arr) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : arr) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
     }
+    return map.size() == new HashSet<>(map.values()).size();
+  }
 }

From 915647c552f62e5f473e592aed3c5b53509ed10b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Aug 2022 19:41:25 -0700
Subject: [PATCH 1248/2175] Update Palindrome Linked List.java

---
 Easy/Palindrome Linked List.java | 61 +++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 24 deletions(-)

diff --git a/Easy/Palindrome Linked List.java b/Easy/Palindrome Linked List.java
index 33fcc9f4..946427e6 100644
--- a/Easy/Palindrome Linked List.java	
+++ b/Easy/Palindrome Linked List.java	
@@ -3,32 +3,45 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
-    public boolean isPalindrome(ListNode head) {
-        ArrayList<Integer> arr = new ArrayList<Integer>();
-        while (head != null) {
-            arr.add(head.val);
-            head = head.next;
-        }
-        
-        if (arr.size() < 2) return true;
-    
-        int i=0;
-        int j = arr.size()-1;
-        
-        while (true) {
-            
-            if (arr.get(i).equals(arr.get(j)) == false) return false;
-            
-            if (arr.size()%2 == 0 && j - i == 1) break;
-            if (arr.size()%2 != 0 && j - i == 2) break;
-            
-            i++;
-            j--;
-        }
-        return true;
+  public boolean isPalindrome(ListNode head) {
+    if (head.next == null) {
+      return true;
     }
+    ListNode slow = head;
+    ListNode fast = head;
+    ListNode prev = null;
+    while (fast != null && fast.next != null) {
+      prev = slow;
+      fast = fast.next.next;
+      slow = slow.next;
+    }
+    ListNode revNode = reverse(slow);
+    while (revNode != null) {
+      if (revNode.val != head.val) {
+        return false;
+      }
+      revNode = revNode.next;
+      head = head.next;
+    }
+    return true;
+  }
+  
+  private ListNode reverse(ListNode node) {
+    ListNode prev = null;
+    ListNode curr = node;
+    ListNode next = node;
+    while (curr != null) {
+      next = curr.next;
+      curr.next = prev;
+      prev = curr;
+      curr = next;
+    }
+    return prev;
+  }
 }

From 2d8310804862cb043865f456318a8cb774916a61 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Aug 2022 19:55:47 -0700
Subject: [PATCH 1249/2175] Update Fizz Buzz.java

---
 Easy/Fizz Buzz.java | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/Easy/Fizz Buzz.java b/Easy/Fizz Buzz.java
index 73fa230f..c28fabc9 100644
--- a/Easy/Fizz Buzz.java	
+++ b/Easy/Fizz Buzz.java	
@@ -1,11 +1,17 @@
 class Solution {
   public List<String> fizzBuzz(int n) {
-    return IntStream.range(1, n + 1)
-        .boxed()
-        .map(e -> (
-                e % 3 == 0 && e % 5 == 0 ? "FizzBuzz"
-                    : (e % 3 == 0 ? "Fizz" : (e % 5 == 0 ? "Buzz" : String.valueOf(e)))
-            )
-        ).collect(Collectors.toList());
-  }
+    List<String> result = new ArrayList<>();
+    for (int i = 1; i <= n; i++) {
+      if (i % 15 == 0) {
+        result.add("FizzBuzz");
+      } else if (i % 3 == 0) {
+        result.add("Fizz");
+      } else if (i % 5 == 0) {
+        result.add("Buzz");
+      } else {
+        result.add(String.valueOf(i));
+      }
+    }
+    return result;
+  } 
 }

From 66ac2aedef0979cbfe65da22947987cfd034f5c9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 23 Aug 2022 14:30:06 -0700
Subject: [PATCH 1250/2175] Update Count Odd Numbers in an Interval Range.java

---
 Easy/Count Odd Numbers in an Interval Range.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Easy/Count Odd Numbers in an Interval Range.java b/Easy/Count Odd Numbers in an Interval Range.java
index 68fe1652..7155bbc8 100644
--- a/Easy/Count Odd Numbers in an Interval Range.java	
+++ b/Easy/Count Odd Numbers in an Interval Range.java	
@@ -1,5 +1,5 @@
 class Solution {
   public int countOdds(int low, int high) {
-    return (high + 1) / 2 - low / 2;
+    return (high - low) / 2 + (low % 2 != 0 || high % 2 != 0 ? 1 : 0);
   }
 }

From ad20e48c8022cd31c6f30974c520e8221472e8c7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 23 Aug 2022 14:34:27 -0700
Subject: [PATCH 1251/2175] Update Assign Cookies.java

---
 Easy/Assign Cookies.java | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/Easy/Assign Cookies.java b/Easy/Assign Cookies.java
index f6a91ecd..6ff366ad 100644
--- a/Easy/Assign Cookies.java	
+++ b/Easy/Assign Cookies.java	
@@ -2,13 +2,14 @@ class Solution {
   public int findContentChildren(int[] g, int[] s) {
     Arrays.sort(g);
     Arrays.sort(s);
-    int contentChildrenCount = 0;
-    for (int i = 0, j = 0; i < s.length && j < g.length; i++) {
-      if (s[i] >= g[j]) {
-        contentChildrenCount++;
-        j++;
+    int gIdx = 0;
+    int sIdx = 0;
+    while (sIdx < s.length && gIdx < g.length) {
+      if (s[sIdx] >= g[gIdx]) {
+        gIdx++;
       }
+      sIdx++;
     }
-    return contentChildrenCount;
+    return gIdx;
   }
 }

From 89781e1ef1b6a7dd91ede9316568ec1fe8828bfa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 23 Aug 2022 14:52:03 -0700
Subject: [PATCH 1252/2175] Update Reformat Date.java

---
 Easy/Reformat Date.java | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/Easy/Reformat Date.java b/Easy/Reformat Date.java
index fdde8bc3..2230d7a6 100644
--- a/Easy/Reformat Date.java	
+++ b/Easy/Reformat Date.java	
@@ -1,16 +1,22 @@
 class Solution {
+  private static final String[] MONTHS = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+  
   public String reformatDate(String date) {
-    String[] months = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-    Map<String, String> monthMap = new HashMap<>();
-    for (int i = 1; i <= 12; i++) {
-      monthMap.put(months[i - 1], (i > 9 ? "" : "0") + i);
-    }
-    String[] strs = date.split("\\s+");
-    int dayEndIdx = 0;
-    while (dayEndIdx < strs[0].length() && Character.isDigit(strs[0].charAt(dayEndIdx))) {
-      dayEndIdx++;
+    String[] split = date.split("\\s+");
+    StringBuilder sb = new StringBuilder();
+    sb.append(split[2]).append("-");
+    int monthIdx = getMonthIdx(split[1]);
+    sb.append(monthIdx > 9 ? "" : "0").append(monthIdx).append("-");
+    sb.append(Character.isDigit(split[0].charAt(1)) ? split[0].substring(0, 2) : ("0" + split[0].charAt(0)));
+    return sb.toString();
+  }
+  
+  private int getMonthIdx(String month) {
+    for (int i = 0; i < MONTHS.length; i++) {
+      if (month.equals(MONTHS[i])) {
+        return i + 1;
+      }
     }
-    String dayStr = strs[0].substring(0, dayEndIdx);
-    return strs[2] + "-" + monthMap.get(strs[1]) + "-" + (dayStr.length() == 2 ? dayStr : "0" + dayStr);
+    return -1;
   }
 }

From c7a8b7596475cea3017968e18129474d5a2ec531 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 23 Aug 2022 15:56:28 -0700
Subject: [PATCH 1253/2175] Update Degree of an array.java

---
 Easy/Degree of an array.java | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/Easy/Degree of an array.java b/Easy/Degree of an array.java
index f4c3f2f3..85c1622e 100644
--- a/Easy/Degree of an array.java	
+++ b/Easy/Degree of an array.java	
@@ -1,24 +1,24 @@
 class Solution {
   public int findShortestSubArray(int[] nums) {
-    Map<Integer, Integer> count = new HashMap<>();
-    Map<Integer, Integer> left = new HashMap<>();
-    Map<Integer, Integer> right = new HashMap<>();
-    int degree = 0;
-    for (int i = 0; i < nums.length; i++) {
-      int num = nums[i];
-      if (!left.containsKey(num)) {
-        left.put(num, i);
-      }
-      right.put(num, i);
-      count.put(num, count.getOrDefault(num, 0) + 1);
-      degree = Math.max(degree, count.get(num));
+    Map<Integer, Integer> map = new HashMap<>();
+    int maxCount = 0;
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+      maxCount = Math.max(maxCount, map.get(num));
     }
-    int ans = nums.length;
-    for (int key : count.keySet()) {
-      if (count.get(key) == degree) {
-        ans = Math.min(ans, right.get(key) - left.get(key) + 1);
+    int start = 0;
+    int end = 0;
+    map.clear();
+    int minLength = Integer.MAX_VALUE;
+    while (end < nums.length) {
+      map.put(nums[end], map.getOrDefault(nums[end], 0) + 1);
+      while (start <= end && map.get(nums[end]) == maxCount) {
+        minLength = Math.min(minLength, end - start + 1);
+        map.put(nums[start], map.get(nums[start]) - 1);
+        start++;
       }
+      end++;
     }
-    return ans;
+    return minLength;
   }
 }

From 9ef560aa860ebbfd32fb2909525aaec926b29698 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 23 Aug 2022 16:10:10 -0700
Subject: [PATCH 1254/2175] Update N-th Tribonacci Number.java

---
 Easy/N-th Tribonacci Number.java | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/Easy/N-th Tribonacci Number.java b/Easy/N-th Tribonacci Number.java
index af3ee26d..23a53a62 100644
--- a/Easy/N-th Tribonacci Number.java	
+++ b/Easy/N-th Tribonacci Number.java	
@@ -1,10 +1,13 @@
 class Solution {
   public int tribonacci(int n) {
-    int[] arr = new int[38];
-    arr[1] = arr[2] = 1;
-    for (int i = 3; i < 38; i++) {
-      arr[i] = arr[i - 1] + arr[i - 2] + arr[i - 3];
+    if (n <= 2) {
+      return n == 0 ? 0 : 1;
     }
-    return arr[n];
+    int[] dp = new int[n + 1];
+    dp[1] = dp[2] = 1;
+    for (int i = 3; i <= n; i++) {
+      dp[i] = dp[i - 2] + dp[i - 1] + dp[i - 3];
+    }
+    return dp[n];
   }
 }

From b60dcad9cc0eb548ec10bbc9469e6788031a7f63 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 23 Aug 2022 17:01:34 -0700
Subject: [PATCH 1255/2175] Update Reverse Bits.java

---
 Easy/Reverse Bits.java | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/Easy/Reverse Bits.java b/Easy/Reverse Bits.java
index e2406b6c..53055d27 100644
--- a/Easy/Reverse Bits.java	
+++ b/Easy/Reverse Bits.java	
@@ -1,11 +1,17 @@
 public class Solution {
+    // you need treat n as an unsigned value
   public int reverseBits(int n) {
-    int res = 0;
+    if (n == 0) {
+      return 0;
+    }
+    int result = 0;
     for (int i = 0; i < 32; i++) {
-      res <<= 1;
-      res = res | (n & 1);
+      result <<= 1;
+      if ((n & 1) == 1) {
+        result++;
+      }
       n >>= 1;
     }
-    return res;
+    return result;
   }
 }

From 0ca17f7ce588e59fdc51f12f7580e9612cccb970 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 23 Aug 2022 18:07:22 -0700
Subject: [PATCH 1256/2175] Update Power of Three.java

---
 Easy/Power of Three.java | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/Easy/Power of Three.java b/Easy/Power of Three.java
index b93756c6..2fbe03e5 100644
--- a/Easy/Power of Three.java	
+++ b/Easy/Power of Three.java	
@@ -1,14 +1,19 @@
 class Solution {
   public boolean isPowerOfThree(int n) {
-    if (n <= 0) {
-      return false;
-    }
-    while (n > 1) {
-      if (n % 3 != 0) {
-        return false;
+    int left = 0;
+    int right = n / 3;
+    while (left <= right) { 
+      int mid = (left + right) / 2;
+      double powValue = Math.pow(3, mid);
+      if (powValue == n) {
+        return true;
+      }
+      if (powValue > n) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
       }
-      n /= 3;
     }
-    return true;
+    return false;
   }
 }

From 31bdd7e8f33358c68baa5c08d53a10ffe1668a25 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Aug 2022 07:51:18 -0700
Subject: [PATCH 1257/2175] Update Subtract the Product and Sum of Digits of an
 Integer.java

---
 ...Product and Sum of Digits of an Integer.java | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/Easy/Subtract the Product and Sum of Digits of an Integer.java b/Easy/Subtract the Product and Sum of Digits of an Integer.java
index 462d8f60..d08e41f7 100644
--- a/Easy/Subtract the Product and Sum of Digits of an Integer.java	
+++ b/Easy/Subtract the Product and Sum of Digits of an Integer.java	
@@ -1,17 +1,12 @@
 class Solution {
   public int subtractProductAndSum(int n) {
     int sum = 0;
-    int copy = n;
-    while (copy > 0) {
-      sum += copy % 10;
-      copy /= 10;
+    int product = 1;
+    while (n > 0) {
+      sum += n % 10;
+      product *= n % 10;
+      n /= 10;
     }
-    int prod = 1;
-    copy = n;
-    while (copy > 0) {
-      prod *= copy % 10;
-      copy /= 10;
-    }
-    return prod - sum;
+    return product - sum;
   }
 }

From 55b3262851612298279f5ca18a335795e88a955f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Aug 2022 10:49:37 -0700
Subject: [PATCH 1258/2175] Update Sorting the Sentence.java

---
 Easy/Sorting the Sentence.java | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Easy/Sorting the Sentence.java b/Easy/Sorting the Sentence.java
index 94b78e3e..6909055c 100644
--- a/Easy/Sorting the Sentence.java	
+++ b/Easy/Sorting the Sentence.java	
@@ -1,20 +1,17 @@
 class Solution {
   public String sortSentence(String s) {
-    String[] arr = new String[s.split(" ").length];
-    int idx = 0;
-    int n = s.length();
-    while (idx < n) {
-      int currIdx = idx;
-      while (currIdx < n && Character.isLetter(s.charAt(currIdx))) {
-        currIdx++;
-      }
-      int wordIdx = Character.getNumericValue(s.charAt(currIdx++));
-      arr[wordIdx - 1] = s.substring(idx, currIdx - 1);
-      idx = currIdx + 1;
+    String[] positions = new String[9];
+    String[] strs = s.split("\\s+");
+    for (String str : strs) {
+      int digit = Character.getNumericValue(str.charAt(str.length() - 1));
+      positions[digit - 1] = str.substring(0, str.length() - 1);
     }
     StringBuilder sb = new StringBuilder();
-    for (String word : arr) {
-      sb.append(word).append(" ");
+    for (int i = 0; i < positions.length; i++) {
+      if (positions[i] == null) {
+        break;
+      }
+      sb.append(positions[i]).append(" ");
     }
     return sb.toString().trim();
   }

From 4e75613375432fe32be606c0c28da6f370c32814 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Aug 2022 11:32:41 -0700
Subject: [PATCH 1259/2175] Update Merge two binary trees.java

---
 Easy/Merge two binary trees.java | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/Easy/Merge two binary trees.java b/Easy/Merge two binary trees.java
index d91c7643..1a487c2c 100644
--- a/Easy/Merge two binary trees.java	
+++ b/Easy/Merge two binary trees.java	
@@ -4,24 +4,24 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
-    if (t1 == null && t2 == null) {
+  public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
+    if (root1 == null && root2 == null) {
       return null;
     }
-    int val = (t1 == null ? 0 : t1.val) + (t2 == null ? 0 : t2.val); 
-    TreeNode root = new TreeNode(val);
-    root.left = mergeTrees(
-      t1 == null ? null : t1.left, 
-      t2 == null ? null : t2.left
-    );
-    root.right = mergeTrees(
-      t1 == null ? null : t1.right, 
-      t2 == null ? null : t2.right
-    );
+    int value = (root1 == null ? 0 : root1.val) + (root2 == null ? 0 : root2.val);
+    TreeNode root = new TreeNode(value);
+    root.left = mergeTrees((root1 == null ? null : root1.left), (root2 == null ? null : root2.left));
+    root.right = mergeTrees((root1 == null ? null : root1.right), (root2 == null ? null : root2.right));
     return root;
   }
 }

From e778d07a19b922b1e2eef69fc2843df95001f866 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Aug 2022 11:44:06 -0700
Subject: [PATCH 1260/2175] Update Find the Middle Index in Array.java

---
 Easy/Find the Middle Index in Array.java | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/Easy/Find the Middle Index in Array.java b/Easy/Find the Middle Index in Array.java
index 9f95a996..4ad9ddbf 100644
--- a/Easy/Find the Middle Index in Array.java	
+++ b/Easy/Find the Middle Index in Array.java	
@@ -1,21 +1,19 @@
 class Solution {
   public int findMiddleIndex(int[] nums) {
-    int[] leftSum = new int[nums.length];
-    int[] rightSum = new int[nums.length];
+    int n = nums.length;
+    int[] rightSum = new int[n];
     int currSum = 0;
-    for (int i = 0; i < nums.length; i++) {
-      leftSum[i] = currSum;
+    for (int i = n - 1; i >= 0; i--) {
       currSum += nums[i];
-    }
-    currSum = 0;
-    for (int i = nums.length - 1; i >= 0; i--) {
       rightSum[i] = currSum;
-      currSum += nums[i];
     }
-    for (int i = 0; i < nums.length; i++) {
-      if (leftSum[i] == rightSum[i]) {
+    currSum = 0;
+    for (int i = 0; i < n; i++) {
+      int rightCurrSum = i != n - 1 ? rightSum[i + 1] : 0;
+      if (currSum == rightCurrSum) {
         return i;
       }
+      currSum += nums[i];
     }
     return -1;
   }

From b39622201c105f3e39c3cf8f9554b7f831762869 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Aug 2022 12:56:37 -0700
Subject: [PATCH 1261/2175] Update Path Sum.java

---
 Easy/Path Sum.java | 40 +++++++++++++++++++++++++++++++---------
 1 file changed, 31 insertions(+), 9 deletions(-)

diff --git a/Easy/Path Sum.java b/Easy/Path Sum.java
index 537ec4bb..dc77aafe 100644
--- a/Easy/Path Sum.java	
+++ b/Easy/Path Sum.java	
@@ -4,17 +4,39 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public boolean hasPathSum(TreeNode root, int sum) {
-        
-        if (root == null) return false;
-        if (root.left == null && root.right == null) {
-            return sum - root.val == 0;
-        }
-        
-        return (root.left != null ? hasPathSum(root.left, sum-root.val) : false) | (root.right != null ? hasPathSum(root.right, sum-root.val) : false);
+  public boolean hasPathSum(TreeNode root, int targetSum) {
+    if (root == null) {
+      return false;
     }
+    Queue<Integer> sumQueue = new LinkedList<>();
+    Queue<TreeNode> nodeQueue = new LinkedList<>();
+    sumQueue.add(targetSum - root.val);
+    nodeQueue.add(root);
+    while (!nodeQueue.isEmpty()) {
+      TreeNode removedNode = nodeQueue.remove();
+      int removedSum = sumQueue.remove();
+      if (removedNode.left == null && removedNode.right == null && removedSum == 0) {
+        return true;
+      }
+      if (removedNode.left != null) {
+        nodeQueue.add(removedNode.left);
+        sumQueue.add(removedSum - removedNode.left.val);
+      }
+      if (removedNode.right != null) {
+        nodeQueue.add(removedNode.right);
+        sumQueue.add(removedSum - removedNode.right.val);
+      }
+    }
+    return false;
+  }
 }

From bd82edb8caa63b73037e3a875eea89d25e047997 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Aug 2022 13:14:12 -0700
Subject: [PATCH 1262/2175] Update Ugly Number.java

---
 Easy/Ugly Number.java | 24 ++++++------------------
 1 file changed, 6 insertions(+), 18 deletions(-)

diff --git a/Easy/Ugly Number.java b/Easy/Ugly Number.java
index e8d27ea0..345df6c7 100644
--- a/Easy/Ugly Number.java	
+++ b/Easy/Ugly Number.java	
@@ -1,23 +1,11 @@
 class Solution {
-  public boolean isUgly(int num) {
-    if (num <= 0) {
-      return false;
-    }
-    long lNum = (long) num;
-    while (lNum > 1) {
-      if (lNum % 2 == 0) {
-        lNum /= 2;
-      }
-      else if (lNum % 3 == 0) {
-        lNum /= 3;
-      }
-      else if (lNum % 5 == 0) {
-        lNum /= 5;
-      }
-      else {
-        return false;
+  public boolean isUgly(int n) {
+    int[] primes = {2, 3, 5};
+    for (int i = 0; i < primes.length; i++) {
+      while (n > 1 && n % primes[i] == 0) {
+        n /= primes[i];
       }
     }
-    return true;
+    return n == 1;
   }
 }

From e2b3adb2bf51a487438a0d3a9a31e331c7f89cf5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Aug 2022 14:50:49 -0700
Subject: [PATCH 1263/2175] Update Kth Missing Positive Number.java

---
 Easy/Kth Missing Positive Number.java | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Easy/Kth Missing Positive Number.java b/Easy/Kth Missing Positive Number.java
index b953be98..6f662c97 100644
--- a/Easy/Kth Missing Positive Number.java	
+++ b/Easy/Kth Missing Positive Number.java	
@@ -1,20 +1,15 @@
 class Solution {
   public int findKthPositive(int[] arr, int k) {
-    for (int i = 0; i < arr.length; i++) {
-      int curr = arr[i] - 1;
-      int prev = i == 0 ? 0 : arr[i - 1];
-      while (prev < curr) {
-        k--;
-        prev++;
-        if (k == 0) {
-          return prev;
-        }
+    int left = 0;
+    int right = arr.length - 1;
+    while (left <= right) {
+      int mid = left + (right - left) / 2;
+      if (arr[mid] - mid - 1 < k) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
       }
     }
-    int curr = arr[arr.length - 1];
-    while (k-- > 0) {
-      curr++;
-    }
-    return curr;
+    return left + k;
   }
 }

From f965c45cab4ef662be975604a3f263299d6fed56 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 25 Aug 2022 14:24:48 -0700
Subject: [PATCH 1264/2175] Update Maximum Nesting Depth of Two Valid
 Parentheses Strings.java

---
 ... Depth of Two Valid Parentheses Strings.java | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java b/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java
index 444efeb0..df70bcb7 100644
--- a/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java	
+++ b/Medium/Maximum Nesting Depth of Two Valid Parentheses Strings.java	
@@ -1,16 +1,11 @@
 class Solution {
   public int[] maxDepthAfterSplit(String seq) {
-    int[] maxDepth = new int[seq.length()];
-    int currDepth = 0;
-    for (int i = 0; i < seq.length(); i++) {
-      if (seq.charAt(i) == '(') {
-        currDepth++;
-      }
-      maxDepth[i] = currDepth % 2;
-      if (seq.charAt(i) != '(') {
-        currDepth--;
-      }
+    int[] result = new int[seq.length()];
+    int idx = 0;
+    int depth = 0;
+    for (char c : seq.toCharArray()) {
+      result[idx++] = c == '(' ? (depth++ % 2) : (--depth % 2);
     }
-    return maxDepth;
+    return result;
   }
 }

From 3c9894dc702f68f613728022865d099157e0d738 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 25 Aug 2022 14:38:55 -0700
Subject: [PATCH 1265/2175] Update Group the People Given the Group Size They
 Belong To.java

---
 ...e Given the Group Size They Belong To.java | 39 ++++++++-----------
 1 file changed, 16 insertions(+), 23 deletions(-)

diff --git a/Medium/Group the People Given the Group Size They Belong To.java b/Medium/Group the People Given the Group Size They Belong To.java
index 003f6099..475cf0c6 100644
--- a/Medium/Group the People Given the Group Size They Belong To.java	
+++ b/Medium/Group the People Given the Group Size They Belong To.java	
@@ -1,27 +1,20 @@
 class Solution {
-    public List<List<Integer>> groupThePeople(int[] groupSizes) {
-        Map<Integer, List<List<Integer>>> map = new HashMap<>();
-        int n = groupSizes.length;
-        for (int i = 0; i < n; i++) {
-            int size = groupSizes[i];
-            if (!map.containsKey(size)) {
-                map.put(size, new ArrayList<>());
-                map.get(size).add(new ArrayList<>());
-            }
-            int arraySize = map.get(size).size();
-            if (map.get(size).get(arraySize - 1).size() == size) {
-                map.get(size).add(new ArrayList<>());
-                arraySize++;
-            }
-            map.get(size).get(arraySize - 1).add(i);
-        }
-        List<List<Integer>> ans = new ArrayList<>();
-        for (Integer key : map.keySet()) {
-            List<List<Integer>> lists = map.get(key);
-            for (List<Integer> list : lists) {
-                ans.add(list);
-            }
+  public List<List<Integer>> groupThePeople(int[] groupSizes) {
+    Map<Integer, Queue<Integer>> groupSizeToId = new HashMap<>();
+    for (int i = 0; i < groupSizes.length; i++) {
+      groupSizeToId.computeIfAbsent(groupSizes[i], k -> new LinkedList<>()).add(i);
+    }
+    List<List<Integer>> result = new ArrayList<>();
+    for (Integer groupSize : groupSizeToId.keySet()) {
+      Queue<Integer> ids = groupSizeToId.get(groupSize);
+      while (!ids.isEmpty()) {
+        List<Integer> group = new ArrayList<>(groupSize);
+        for (int i = 0; i< groupSize; i++) {
+          group.add(ids.remove());
         }
-        return ans;
+        result.add(group);
+      }
     }
+    return result;
+  }
 }

From 3a9070b05adccac356c47f8232f19cee6d22bb26 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 26 Aug 2022 09:08:33 -0700
Subject: [PATCH 1266/2175] Create Reordered Power of 2.java

---
 Medium/Reordered Power of 2.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Reordered Power of 2.java

diff --git a/Medium/Reordered Power of 2.java b/Medium/Reordered Power of 2.java
new file mode 100644
index 00000000..09c9fe1b
--- /dev/null
+++ b/Medium/Reordered Power of 2.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public boolean reorderedPowerOf2(int n) {
+    int[] digitCount = count(n);
+    for (int i = 0; i < 31; i++) {
+      if (Arrays.equals(digitCount, count(1 << i))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  private int[] count(int n) {
+    int[] result = new int[10];
+    while (n > 0) {
+      result[n % 10]++;
+      n /= 10;
+    }
+    return result;
+  }
+}

From 0c439139e5c1d5e2bbe5f032bb43bc36deb2ce2f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 26 Aug 2022 12:29:15 -0700
Subject: [PATCH 1267/2175] Update Design Add and Search Words Data
 Structure.java

---
 ...n Add and Search Words Data Structure.java | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/Medium/Design Add and Search Words Data Structure.java b/Medium/Design Add and Search Words Data Structure.java
index 0f87fece..45fc78fd 100644
--- a/Medium/Design Add and Search Words Data Structure.java	
+++ b/Medium/Design Add and Search Words Data Structure.java	
@@ -1,51 +1,51 @@
 class WordDictionary {
-
-  private final TrieNode root;
-
+  
+  private Node root;
+  
   public WordDictionary() {
-    this.root = new TrieNode();
+    this.root = new Node();
   }
 
   public void addWord(String word) {
-    TrieNode curr = root;
+    Node curr = root;
     for (char c : word.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        curr.children.put(c, new TrieNode());
+      if (curr.children[c - 'a'] == null) {
+        curr.children[c - 'a'] = new Node();
       }
-      curr = curr.children.get(c);
+      curr = curr.children[c - 'a'];
     }
     curr.isWord = true;
   }
 
   public boolean search(String word) {
-    return searchHelper(word, 0, root);
+    Node curr = root;
+    return searchHelper(word, 0, curr);
   }
-
-  private boolean searchHelper(String word, int idx, TrieNode curr) {
+  
+  private boolean searchHelper(String word, int idx, Node curr) {
     if (idx == word.length()) {
       return curr.isWord;
     }
-    if (curr.children.containsKey(word.charAt(idx))) {
-      return searchHelper(word, idx + 1, curr.children.get(word.charAt(idx)));
+    if (word.charAt(idx) != '.' && curr.children[word.charAt(idx) - 'a'] == null) {
+      return false;
     }
     if (word.charAt(idx) == '.') {
-      for (char c : curr.children.keySet()) {
-        if (searchHelper(word, idx + 1, curr.children.get(c))) {
+      for (Node child : curr.children) {
+        if (child != null && searchHelper(word, idx + 1, child)) {
           return true;
         }
       }
+      return false;
     }
-    return false;
+    return searchHelper(word, idx + 1, curr.children[word.charAt(idx) - 'a']);
   }
-
-
-  private static class TrieNode {
-
-    private final Map<Character, TrieNode> children;
-    private boolean isWord;
-
-    public TrieNode() {
-      this.children = new HashMap<>();
+  
+  private static class Node {
+    Node[] children;
+    boolean isWord;
+    
+    public Node() {
+      this.children = new Node[26];
       this.isWord = false;
     }
   }

From a65bf0843a55d0b846dc1584582cef2260e0dfaf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 27 Aug 2022 17:20:50 -0700
Subject: [PATCH 1268/2175] Create Remove Duplicates From an Unsorted Linked
 List.java

---
 ...plicates From an Unsorted Linked List.java | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Medium/Remove Duplicates From an Unsorted Linked List.java

diff --git a/Medium/Remove Duplicates From an Unsorted Linked List.java b/Medium/Remove Duplicates From an Unsorted Linked List.java
new file mode 100644
index 00000000..e62d60c7
--- /dev/null
+++ b/Medium/Remove Duplicates From an Unsorted Linked List.java	
@@ -0,0 +1,39 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+  public ListNode deleteDuplicatesUnsorted(ListNode head) {
+    Map<Integer, Integer> map = new HashMap<>();
+    ListNode curr = head;
+    while (curr != null) {
+      map.put(curr.val, map.getOrDefault(curr.val, 0) + 1);
+      curr = curr.next;
+    }
+    curr = head;
+    ListNode newHead = null;
+    ListNode prev = null;
+    while (curr != null) {
+      if (map.get(curr.val) > 1) {
+        ListNode nextNode = curr.next;
+        if (prev != null) {
+          prev.next = nextNode;
+        }
+        curr = nextNode;
+      } else {
+        if (newHead == null) {
+          newHead = curr;
+        }
+        prev = curr;
+        curr = curr.next;
+      }
+    }
+    return newHead;
+  }
+}

From 4aec52c84608272fa5680680f6cc6fe3bcc6c18a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 27 Aug 2022 18:32:44 -0700
Subject: [PATCH 1269/2175] Update Number of Recent Calls.java

---
 Easy/Number of Recent Calls.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Easy/Number of Recent Calls.java b/Easy/Number of Recent Calls.java
index 230dc7be..4b039208 100644
--- a/Easy/Number of Recent Calls.java	
+++ b/Easy/Number of Recent Calls.java	
@@ -1,16 +1,16 @@
 class RecentCounter {
-  Queue<Integer> queue;
-  int limit;
+  
+  private Queue<Integer> queue;
+  
   public RecentCounter() {
     queue = new LinkedList<>();
-    limit = 3000;
   }
 
   public int ping(int t) {
-    queue.add(t);
-    while (!queue.isEmpty() && ((t - queue.peek()) > limit)) {
+    while (!queue.isEmpty() && t - queue.peek() > 3000) {
       queue.remove();
     }
+    queue.add(t);
     return queue.size();
   }
 }

From 11a5531d804b93b94a8229947d2cad2be3651622 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 07:48:00 -0700
Subject: [PATCH 1270/2175] Create Removing Stars From a String.java

---
 Medium/Removing Stars From a String.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Removing Stars From a String.java

diff --git a/Medium/Removing Stars From a String.java b/Medium/Removing Stars From a String.java
new file mode 100644
index 00000000..0cb79bea
--- /dev/null
+++ b/Medium/Removing Stars From a String.java	
@@ -0,0 +1,17 @@
+class Solution {
+  public String removeStars(String s) {
+    Stack<Character> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
+      if (c == '*') {
+        stack.pop();
+      } else {
+        stack.push(c);
+      }
+    }
+    StringBuilder sb = new StringBuilder();
+    while (!stack.isEmpty()) {
+      sb.append(stack.pop());
+    }
+    return sb.reverse().toString();
+  }
+}

From 72d3339d8e8fd4632f9dfc3a8a18b6155bfd37fa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 07:55:30 -0700
Subject: [PATCH 1271/2175] Create Longest Subsequence With Limited Sum.java

---
 Easy/Longest Subsequence With Limited Sum.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Longest Subsequence With Limited Sum.java

diff --git a/Easy/Longest Subsequence With Limited Sum.java b/Easy/Longest Subsequence With Limited Sum.java
new file mode 100644
index 00000000..5dd527a5
--- /dev/null
+++ b/Easy/Longest Subsequence With Limited Sum.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int[] answerQueries(int[] nums, int[] queries) {
+    Arrays.sort(nums);
+    Arrays.parallelPrefix(nums, Integer::sum);
+    for (int i = 0; i < queries.length; i++) {
+      int idx = Arrays.binarySearch(nums, queries[i]);
+      queries[i] = Math.abs(idx + 1);
+    }
+    return queries;
+  }
+}

From 9d82d58b7e3e48acffc6ed8db77a6072218d16bf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 08:26:06 -0700
Subject: [PATCH 1272/2175] Create Minimum Amount of Time to Collect
 Garbage.java

---
 ...mum Amount of Time to Collect Garbage.java | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Minimum Amount of Time to Collect Garbage.java

diff --git a/Medium/Minimum Amount of Time to Collect Garbage.java b/Medium/Minimum Amount of Time to Collect Garbage.java
new file mode 100644
index 00000000..b0ac91ff
--- /dev/null
+++ b/Medium/Minimum Amount of Time to Collect Garbage.java	
@@ -0,0 +1,34 @@
+class Solution {
+  public int garbageCollection(String[] garbage, int[] travel) {
+    int[] lastIdx = {-1, -1, -1};
+    Map<Integer, int[]> garbageCount = new HashMap<>();
+    for (int i = 0; i < garbage.length; i++) {
+      garbageCount.put(i, new int[3]);
+      for (char c : garbage[i].toCharArray()) {
+        if (c == 'M') {
+          lastIdx[0] = i;
+          garbageCount.get(i)[0]++;
+        }
+        if (c == 'P') {
+          lastIdx[1] = i;
+          garbageCount.get(i)[1]++;
+        }
+        if (c == 'G') {
+          lastIdx[2] = i;
+          garbageCount.get(i)[2]++;
+        }
+      }
+    }
+    int time = 0;
+    for (int i = 0; i < 3; i++) {
+      for (int j = 0; j < garbage.length; j++) {
+        if (lastIdx[i] < j) {
+          break;
+        }
+        time += j == 0 ? 0 : travel[j - 1];
+        time += garbageCount.get(j)[i];
+      }
+    }
+    return time;
+  }
+}

From 30f3b2985a2bcab41e408519e6c97d38348f82c7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 12:55:36 -0700
Subject: [PATCH 1273/2175] Update and rename Hard/Binary Tree PostOrder
 Traversal.java to Easy/Binary Tree PostOrder Traversal.java

---
 Easy/Binary Tree PostOrder Traversal.java | 34 +++++++++++++++++++
 Hard/Binary Tree PostOrder Traversal.java | 41 -----------------------
 2 files changed, 34 insertions(+), 41 deletions(-)
 create mode 100644 Easy/Binary Tree PostOrder Traversal.java
 delete mode 100644 Hard/Binary Tree PostOrder Traversal.java

diff --git a/Easy/Binary Tree PostOrder Traversal.java b/Easy/Binary Tree PostOrder Traversal.java
new file mode 100644
index 00000000..4e839ba8
--- /dev/null
+++ b/Easy/Binary Tree PostOrder Traversal.java	
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public List<Integer> postorderTraversal(TreeNode root) {
+    List<Integer> result = new ArrayList<>();
+    Stack<TreeNode> stack = new Stack<>();
+    TreeNode node = root;
+    while (!stack.isEmpty() || node != null) {
+      if (node != null) {
+        stack.push(node);
+        result.add(node.val);
+        node = node.right;
+      } else {  
+        TreeNode removed = stack.pop();
+        node = removed.left; 
+      }
+    }
+    Collections.reverse(result);
+    return result;
+  }
+}
diff --git a/Hard/Binary Tree PostOrder Traversal.java b/Hard/Binary Tree PostOrder Traversal.java
deleted file mode 100644
index 53983b32..00000000
--- a/Hard/Binary Tree PostOrder Traversal.java	
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public List<Integer> postorderTraversal(TreeNode root) {
-        List<Integer> values = new ArrayList<>();
-        if (root == null) {
-            return values;
-        }
-
-        Stack<TreeNode> stack1 = new Stack<>();
-        Stack<TreeNode> stack2 = new Stack<>();
-
-        stack1.push(root);
-
-        while (!stack1.empty()) {
-            TreeNode temp = stack1.pop();
-            stack2.push(temp);
-
-            if (temp.left != null) {
-                stack1.push(temp.left);
-            }
-
-            if (temp.right != null) {
-                stack1.push(temp.right);
-            }
-        }
-
-        while (!stack2.empty()) {
-            values.add(stack2.pop().val);
-        }
-        
-        return values;
-    }
-}

From 2bca553a5ba52cf4ea043b0ded19d4796e68508c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 12:55:46 -0700
Subject: [PATCH 1274/2175] Rename Binary Tree PostOrder Traversal.java to
 Binary Tree Postorder Traversal.java

---
 ...tOrder Traversal.java => Binary Tree Postorder Traversal.java} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename Easy/{Binary Tree PostOrder Traversal.java => Binary Tree Postorder Traversal.java} (100%)

diff --git a/Easy/Binary Tree PostOrder Traversal.java b/Easy/Binary Tree Postorder Traversal.java
similarity index 100%
rename from Easy/Binary Tree PostOrder Traversal.java
rename to Easy/Binary Tree Postorder Traversal.java

From 893686cd9bec10fc159add1ad14fba76edf262f7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 14:18:08 -0700
Subject: [PATCH 1275/2175] Update Binary Tree Paths.java

---
 Easy/Binary Tree Paths.java | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/Easy/Binary Tree Paths.java b/Easy/Binary Tree Paths.java
index 08dfef94..72739836 100644
--- a/Easy/Binary Tree Paths.java	
+++ b/Easy/Binary Tree Paths.java	
@@ -4,32 +4,33 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  List<String> list;
   public List<String> binaryTreePaths(TreeNode root) {
-    list = new ArrayList<>();
-    if (root == null) {
-      return list;
-    }
-    helper(root, new StringBuilder());
-    return list;
+    List<String> result = new ArrayList<>();
+    helper(root, result, new StringBuilder());
+    return result;
   }
   
-  private void helper(TreeNode root, StringBuilder sb) {
+  private void helper(TreeNode root, List<String> result, StringBuilder path) {
     if (root == null) {
       return;
     }
+    path.append(root.val);
     if (root.left == null && root.right == null) {
-      sb.append(root.val);
-      list.add(sb.toString());
-    }
-    else {
-      sb.append(root.val).append("->");
-      helper(root.left, new StringBuilder(sb.toString()));
-      helper(root.right, new StringBuilder(sb.toString()));
+      result.add(path.toString());
+    } else {
+      path.append("->");
+      helper(root.left, result, new StringBuilder(path));
+      helper(root.right, result, new StringBuilder(path));
     }
   }
 }

From f47b20d24b55e6b35aa7e9d7bb6de8dee8ef6086 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 14:23:57 -0700
Subject: [PATCH 1276/2175] Update Summary Ranges.java

---
 Easy/Summary Ranges.java | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/Easy/Summary Ranges.java b/Easy/Summary Ranges.java
index 97b5e753..cf67a700 100644
--- a/Easy/Summary Ranges.java	
+++ b/Easy/Summary Ranges.java	
@@ -1,19 +1,18 @@
 class Solution {
   public List<String> summaryRanges(int[] nums) {
-    List<String> ranges = new ArrayList<>();
+    List<String> result = new ArrayList<>();
     int idx = 0;
-    while (idx < nums.length) {
-      int start = nums[idx++];
+    int n = nums.length;
+    while (idx < n) {
+      int start = nums[idx];
       int end = start;
-      while (idx < nums.length && (nums[idx] - end) == 1) {
-        end = nums[idx++];
-      }
-      if (start == end) {
-        ranges.add(String.valueOf(start));
-      } else {
-        ranges.add(String.format("%d->%d", start, end));
+      idx++;
+      while (idx < n && nums[idx] == end + 1) {
+        end = nums[idx];
+        idx++;
       }
+      result.add(start == end ? String.valueOf(start) : (start + "->" + end));
     }
-    return ranges;
+    return result;
   }
 }

From 13756629008c32e23f039f274d103a46576378c2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 15:32:09 -0700
Subject: [PATCH 1277/2175] Create Valid Word Square.java

---
 Easy/Valid Word Square.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Valid Word Square.java

diff --git a/Easy/Valid Word Square.java b/Easy/Valid Word Square.java
new file mode 100644
index 00000000..69e1925d
--- /dev/null
+++ b/Easy/Valid Word Square.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public boolean validWordSquare(List<String> words) {
+    return IntStream.range(0, words.size())
+        .allMatch(i -> words.get(i).equals(verticalRepresentation(words, i)));
+  }
+
+  private String verticalRepresentation(List<String> words, int col){
+    StringBuilder sb = new StringBuilder();
+    for (String word : words) {
+      if (col < word.length()) {
+        sb.append(word.charAt(col));
+      }
+    }
+    return sb.toString();
+  }
+}

From 2e836748ab344651fab506eee1fe41dfd16b719e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Aug 2022 17:59:17 -0700
Subject: [PATCH 1278/2175] Update Number of Islands.java

---
 Medium/Number of Islands.java | 41 +++++++++++++++--------------------
 1 file changed, 18 insertions(+), 23 deletions(-)

diff --git a/Medium/Number of Islands.java b/Medium/Number of Islands.java
index cebe59c1..ecf3afb7 100644
--- a/Medium/Number of Islands.java	
+++ b/Medium/Number of Islands.java	
@@ -1,38 +1,33 @@
 class Solution {
   
-  private static final int[][] DIRS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
   
   public int numIslands(char[][] grid) {
-    int countOfIslands = 0;
-    int numOfRows = grid.length;
-    int numOfCols = grid[0].length;
-    boolean[][] visited = new boolean[numOfRows][numOfCols];
-    for (int i = 0; i < numOfRows; i++) {
-      for (int j = 0; j < numOfCols; j++) {
-        if (!visited[i][j] && grid[i][j] == '1') {
+    int rows = grid.length;
+    int cols = grid[0].length;
+    boolean[][] visited = new boolean[rows][cols];
+    int islandCount = 0;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (grid[i][j] == '1' && !visited[i][j]) {
           Queue<int[]> queue = new LinkedList<>();
           queue.add(new int[]{i, j});
+          visited[i][j] = true;
           while (!queue.isEmpty()) {
-            int size = queue.size();
-            while (size-- > 0) {
-              int[] removed = queue.remove();
-              int currX = removed[0];
-              int currY = removed[1];
-              visited[currX][currY] = true;
-              for (int[] dir : DIRS) {
-                int newX = currX + dir[0];
-                int newY = currY + dir[1];
-                if (newX >= 0 && newY >= 0 && newX < numOfRows && newY < numOfCols && !visited[newX][newY] && grid[newX][newY] == '1') {
-                  queue.add(new int[]{newX, newY});
-                  visited[newX][newY] = true;
-                }
+            int[] removed = queue.remove();
+            for (int[] dir : DIRS) {
+              int newX = removed[0] + dir[0];
+              int newY = removed[1] + dir[1];
+              if (newX >= 0 && newY >= 0 && newX < rows && newY < cols && !visited[newX][newY] && grid[newX][newY] == '1') {
+                visited[newX][newY] = true;
+                queue.add(new int[]{newX, newY});
               }
             }
           }
-          countOfIslands++;
+          islandCount++;
         }
       }
     }
-    return countOfIslands;
+    return islandCount;
   }
 }

From 7150410a962c125b9f4236645e05b501c76b8e70 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 29 Aug 2022 15:48:14 -0700
Subject: [PATCH 1279/2175] Update Find Elements in a Contaminated Binary
 Tree.java

---
 ...lements in a Contaminated Binary Tree.java | 46 +++++++++++--------
 1 file changed, 26 insertions(+), 20 deletions(-)

diff --git a/Medium/Find Elements in a Contaminated Binary Tree.java b/Medium/Find Elements in a Contaminated Binary Tree.java
index 2015bd92..9048fbd2 100644
--- a/Medium/Find Elements in a Contaminated Binary Tree.java	
+++ b/Medium/Find Elements in a Contaminated Binary Tree.java	
@@ -4,30 +4,36 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class FindElements {
-    TreeNode root;
-    Set<Integer> set;
-    public FindElements(TreeNode root) {
-        set = new HashSet<>();
-        buildTree(root, 0);
-    }
-    
-    private void buildTree(TreeNode root, int val) {
-        if (root == null) {
-            return;
-        }
-        root.val = val;
-        set.add(val);
-        buildTree(root.left, 2 * val + 1);
-        buildTree(root.right, 2 * val + 2);
-    }
-    
-    public boolean find(int target) {
-        return set.contains(target);
+
+  private Set<Integer> set;
+  
+  public FindElements(TreeNode root) {
+    set = new HashSet<>();
+    recover(root, 0);
+  }
+  
+  private void recover(TreeNode root, int value) {
+    if (root == null) {
+      return;
     }
+    set.add(value);
+    recover(root.left, 2 * value + 1);
+    recover(root.right, 2 * value + 2);
+  }
+
+  public boolean find(int target) {
+    return set.contains(target);
+  }
 }
 
 /**

From 6559fab89e51287181e368a22071f6667217b3dd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 30 Aug 2022 14:24:48 -0700
Subject: [PATCH 1280/2175] Update Detect Capital.java

---
 Easy/Detect Capital.java | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/Easy/Detect Capital.java b/Easy/Detect Capital.java
index b27943e7..863fe0f5 100644
--- a/Easy/Detect Capital.java	
+++ b/Easy/Detect Capital.java	
@@ -1,21 +1,25 @@
 class Solution {
   public boolean detectCapitalUse(String word) {
-    boolean firstCapital = Character.isUpperCase(word.charAt(0));
+    boolean firstUpperCase = Character.isUpperCase(word.charAt(0));
+    boolean allUpperCase = false;
     for (int i = 1; i < word.length(); i++) {
       if (Character.isUpperCase(word.charAt(i))) {
-        if (!firstCapital || !firstTwoCharactersCapital(word)) {
+        if (!firstUpperCase) {
           return false;
         }
+        if (i == 1) {
+          allUpperCase = true;
+        } else {
+          if (!allUpperCase) {
+            return false;
+          }
+        }
       } else {
-        if (i > 1 && firstTwoCharactersCapital(word)) {
+        if (allUpperCase) {
           return false;
         }
       }
     }
     return true;
   }
-  
-  private boolean firstTwoCharactersCapital(String word) {
-    return Character.isUpperCase(word.charAt(0)) && Character.isUpperCase(word.charAt(1));
-  }
 }

From 9c8d6097f68c37ccca0363dbd6f40c76177b145a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 31 Aug 2022 13:35:07 -0700
Subject: [PATCH 1281/2175] Update and rename Easy/Max Stack.java to Hard/Max
 Stack.java

---
 Easy/Max Stack.java | 91 ---------------------------------------------
 Hard/Max Stack.java | 85 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+), 91 deletions(-)
 delete mode 100644 Easy/Max Stack.java
 create mode 100644 Hard/Max Stack.java

diff --git a/Easy/Max Stack.java b/Easy/Max Stack.java
deleted file mode 100644
index e320e096..00000000
--- a/Easy/Max Stack.java	
+++ /dev/null
@@ -1,91 +0,0 @@
-class MaxStack {
-
-  private Node stackHead;
-  private Node stackTail;
-  private PriorityQueue<Integer> maxValues;
-  private Map<Integer, Stack<Node>> valToNodeMapping;
-
-  public MaxStack() {
-    this.stackHead = new Node(Integer.MIN_VALUE);
-    this.stackTail = new Node(Integer.MAX_VALUE);
-    this.stackTail.prev = this.stackHead;
-    this.stackHead.next = this.stackTail;
-    this.maxValues = new PriorityQueue<>((o1, o2) -> o2 - o1);
-    this.valToNodeMapping = new HashMap<>();
-  }
-
-  public void push(int x) {
-    Node node = new Node(x);
-    if (!this.valToNodeMapping.containsKey(x)) {
-      this.maxValues.add(x);
-    }
-    addNodeToStack(node);
-    this.valToNodeMapping.computeIfAbsent(x, k -> new Stack<>()).push(node);
-  }
-
-  public int pop() {
-    Node toRemove = this.stackHead.next;
-    this.valToNodeMapping.get(toRemove.val).pop();
-    removeNodeFromStack(toRemove);
-    return toRemove.val;
-  }
-
-  public int top() {
-    return this.stackHead.next.val;
-  }
-
-  public int peekMax() {
-    moveToMaxValue();
-    int maxVal = this.maxValues.peek();
-    return this.valToNodeMapping.get(maxVal).peek().val;
-  }
-
-  public int popMax() {
-    moveToMaxValue();
-    int maxVal = this.maxValues.peek();
-    Node toRemove = this.valToNodeMapping.get(maxVal).pop();
-    removeNodeFromStack(toRemove);
-    return toRemove.val;
-  }
-  
-  private void moveToMaxValue() {
-    while (this.valToNodeMapping.get(this.maxValues.peek()).isEmpty()) {
-      this.valToNodeMapping.remove(this.maxValues.poll());
-    }
-  }
-
-  private void addNodeToStack(Node node) {
-    Node nextToHead = this.stackHead.next;
-    nextToHead.prev = node;
-    node.next = nextToHead;
-    this.stackHead.next = node;
-    node.prev = this.stackHead;
-  }
-
-  private void removeNodeFromStack(Node node) {
-    Node nextNode = node.next;
-    Node prevNode = node.prev;
-    prevNode.next = nextNode;
-    nextNode.prev = prevNode;
-  }
-
-  private static class Node {
-    int val;
-    Node next;
-    Node prev;
-
-    public Node(int val) {
-      this.val = val;
-    }
-  }
-}
-
-/**
- * Your MaxStack object will be instantiated and called as such:
- * MaxStack obj = new MaxStack();
- * obj.push(x);
- * int param_2 = obj.pop();
- * int param_3 = obj.top();
- * int param_4 = obj.peekMax();
- * int param_5 = obj.popMax();
- */
diff --git a/Hard/Max Stack.java b/Hard/Max Stack.java
new file mode 100644
index 00000000..918b74b5
--- /dev/null
+++ b/Hard/Max Stack.java	
@@ -0,0 +1,85 @@
+class MaxStack {
+  
+  private TreeMap<Integer, Stack<Node>> map;
+  private Node head;
+  private Node tail;
+  
+  public MaxStack() {
+    this.map = new TreeMap<>();
+    this.head = new Node(-1);
+    this.tail = new Node(-1);
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+
+  public void push(int x) {
+    Node node = createNode(x);
+    map.computeIfAbsent(x, k -> new Stack<>()).push(node);
+  }
+  
+  private Node createNode(int x) {
+    Node node = new Node(x);
+    Node prevToTail = tail.prev;
+    node.next = tail;
+    tail.prev = node;
+    prevToTail.next = node;
+    node.prev = prevToTail;
+    return node;
+  }
+
+  public int pop() {
+    Node toRemove = tail.prev;
+    int val = toRemove.val;
+    map.get(val).pop();
+    if (map.get(val).isEmpty()) {
+      map.remove(val);
+    }
+    removeNode(toRemove);
+    return toRemove.val;
+  }
+
+  public int top() {
+    return tail.prev.val;
+  }
+
+  public int peekMax() {
+    return map.lastKey();
+  }
+
+  public int popMax() {
+    int val = map.lastKey();
+    Node node = map.get(val).pop();
+    if (map.get(val).isEmpty()) {
+      map.remove(val);
+    }
+    removeNode(node);
+    return val;
+  }
+  
+  private void removeNode(Node node) {
+    Node prevNode = node.prev;
+    Node nextNode = node.next;
+    prevNode.next = nextNode;
+    nextNode.prev = prevNode;
+  }
+  
+  private static class Node {
+    Node next;
+    Node prev;
+    int val;
+    
+    public Node(int val) {
+      this.val = val;
+    }
+  }
+}
+
+/**
+ * Your MaxStack object will be instantiated and called as such:
+ * MaxStack obj = new MaxStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.top();
+ * int param_4 = obj.peekMax();
+ * int param_5 = obj.popMax();
+ */

From 6ef2d3fc60bf9bfa27005955fe05cdcad0a298cd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 1 Sep 2022 08:37:28 -0700
Subject: [PATCH 1282/2175] Update Car Pooling.java

---
 Medium/Car Pooling.java | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/Medium/Car Pooling.java b/Medium/Car Pooling.java
index 1199d3b5..9d09b2c4 100644
--- a/Medium/Car Pooling.java	
+++ b/Medium/Car Pooling.java	
@@ -1,17 +1,16 @@
 class Solution {
   public boolean carPooling(int[][] trips, int capacity) {
-    Arrays.sort(trips, Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[2]));
-    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(o -> o[2]));
-    int idx = 0;
-    while (idx < trips.length) {
-      while (!priorityQueue.isEmpty() && priorityQueue.peek()[2] <= trips[idx][1]) {
-        capacity += priorityQueue.poll()[0];
+    Arrays.sort(trips, Comparator.comparingInt(o -> o[1]));
+    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[2]));
+    for (int[] trip : trips) {
+      while (!pq.isEmpty() && pq.peek()[2] <= trip[1]) {
+        capacity += pq.poll()[0];
       }
-      if (capacity < trips[idx][0]) {
+      if (capacity < trip[0]) {
         return false;
       }
-      priorityQueue.add(trips[idx]);
-      capacity -= trips[idx++][0];
+      pq.add(trip);
+      capacity -= trip[0];
     }
     return true;
   }

From 9c98ee491321d34134196d13c46d547739867401 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 1 Sep 2022 08:43:47 -0700
Subject: [PATCH 1283/2175] Update Online Election.java

---
 Medium/Online Election.java | 54 +++++++++----------------------------
 1 file changed, 12 insertions(+), 42 deletions(-)

diff --git a/Medium/Online Election.java b/Medium/Online Election.java
index 34bc11ad..50dfc559 100644
--- a/Medium/Online Election.java	
+++ b/Medium/Online Election.java	
@@ -1,44 +1,24 @@
 class TopVotedCandidate {
 
-  List<Winner> winners;
+  private TreeMap<Integer, Integer> currWinner;
+
   public TopVotedCandidate(int[] persons, int[] times) {
-    winners = new ArrayList<>();
-    Map<Integer, Integer> countMap = new HashMap<>();
-    Map<Integer, Integer> timeMap = new HashMap<>();
-    int maxVotes = 0;
+    this.currWinner = new TreeMap<>();
+    Map<Integer, Integer> candidateToVotecount = new HashMap<>();
+    int currWinningCandidate = -1;
     for (int i = 0; i < persons.length; i++) {
-      countMap.put(persons[i], countMap.getOrDefault(persons[i], 0) + 1);
-      timeMap.put(persons[i], times[i]);
-      if (countMap.get(persons[i]) >= maxVotes) {
-        winners.add(new Winner(times[i], persons[i]));
-        maxVotes = Math.max(maxVotes, countMap.get(persons[i]));
+      int person = persons[i];
+      int newVoteCount = candidateToVotecount.getOrDefault(person, 0) + 1;
+      candidateToVotecount.put(person, newVoteCount);
+      if (currWinningCandidate == -1 || newVoteCount >= candidateToVotecount.get(currWinningCandidate)) {
+        currWinningCandidate = person;
       }
+      currWinner.put(times[i], currWinningCandidate);
     }
   }
 
   public int q(int t) {
-    return winners.get(binarySearchHelper(t)).val;
-  }
-  
-  private int binarySearchHelper(int target) {
-    int start = 0;
-    int end = winners.size() - 1;
-    int idx = 0;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (winners.get(mid).time == target) {
-        idx = mid;
-        break;
-      }
-      else if (winners.get(mid).time < target) {  
-        idx = mid;
-        start = mid + 1;
-      }
-      else {
-        end = mid - 1;
-      }
-    }
-    return idx == winners.size() ? 0 : idx;
+    return this.currWinner.floorEntry(t).getValue();
   }
 }
 
@@ -47,13 +27,3 @@ else if (winners.get(mid).time < target) {
  * TopVotedCandidate obj = new TopVotedCandidate(persons, times);
  * int param_1 = obj.q(t);
  */
-
-class Winner {
-  int time;
-  int val;
-  
-  public Winner(int time, int val) {
-    this.time = time;
-    this.val = val;
-  }
-}

From 64a9ecee670ae225f3b16cc6985dc50b31a48e00 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 1 Sep 2022 14:43:28 -0700
Subject: [PATCH 1284/2175] Update and rename Easy/Path Sum III.java to
 Medium/Path Sum III.java

---
 Easy/Path Sum III.java   | 24 ------------------------
 Medium/Path Sum III.java | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+), 24 deletions(-)
 delete mode 100644 Easy/Path Sum III.java
 create mode 100644 Medium/Path Sum III.java

diff --git a/Easy/Path Sum III.java b/Easy/Path Sum III.java
deleted file mode 100644
index 08c0fd85..00000000
--- a/Easy/Path Sum III.java	
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-  public int pathSum(TreeNode root, int sum) {
-    if (root == null) {
-      return 0;
-    }
-    return helper(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
-  }
-  
-  private int helper(TreeNode root, int sum) {
-    if (root == null) {
-      return 0;
-    }
-    return (root.val == sum ? 1 : 0) + helper(root.left, sum - root.val) +  helper(root.right, sum - root.val);
-  }
-}
diff --git a/Medium/Path Sum III.java b/Medium/Path Sum III.java
new file mode 100644
index 00000000..69badada
--- /dev/null
+++ b/Medium/Path Sum III.java	
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public int pathSum(TreeNode root, int targetSum) {
+    Map<Long, Integer> map = new HashMap<>();
+    map.put(0L, 1);
+    int[] count = {0};
+    preorder(root, 0L, map, count, targetSum);
+    return count[0];
+  }
+  
+  private void preorder(TreeNode root, long currSum, Map<Long, Integer> map, int[] count, int targetSum) {
+    if (root == null) {
+      return;
+    }
+    currSum += root.val;
+    count[0] += map.getOrDefault(currSum - targetSum, 0);
+    map.put(currSum, map.getOrDefault(currSum, 0) + 1);
+    preorder(root.left, currSum, map, count, targetSum);
+    preorder(root.right, currSum, map, count, targetSum);
+    map.put(currSum, map.get(currSum) - 1);
+  }
+}

From 000bad160a4be38b78764dcece56b2811ba01ff2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 2 Sep 2022 11:21:59 -0700
Subject: [PATCH 1285/2175] Update Cousins in Binary Tree.java

---
 Easy/Cousins in Binary Tree.java | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/Easy/Cousins in Binary Tree.java b/Easy/Cousins in Binary Tree.java
index 6d76a140..f2325e25 100644
--- a/Easy/Cousins in Binary Tree.java	
+++ b/Easy/Cousins in Binary Tree.java	
@@ -15,30 +15,30 @@
  */
 class Solution {
   public boolean isCousins(TreeNode root, int x, int y) {
-    NodeDetail nodeDetailX = getNodeDetail(root, x, null, 0);
-    NodeDetail nodeDetailY = getNodeDetail(root, y, null, 0);
-    return nodeDetailX.depth == nodeDetailY.depth && nodeDetailX.parent != nodeDetailY.parent;
+    ParentDepthPair xPair = getParentDepthPair(root, x, 0);
+    ParentDepthPair yPair = getParentDepthPair(root, y, 0);
+    return xPair.parent != yPair.parent && xPair.depth == yPair.depth;
   }
   
-  private NodeDetail getNodeDetail(TreeNode root, int n, TreeNode parent, int depth) {
+  private ParentDepthPair getParentDepthPair(TreeNode root, int val, int currDepth) {
     if (root == null) {
       return null;
     }
-    if (root.val == n) {
-      return new NodeDetail(parent, depth);
+    if (root.val == val) {
+      return new ParentDepthPair(root, currDepth);
     }
-    NodeDetail left = getNodeDetail(root.left, n, root, depth + 1);
-    if (left != null) {
-      return left;
+    if ((root.left != null && root.left.val == val) || (root.right != null && root.right.val == val)) {
+      return new ParentDepthPair(root, currDepth);
     }
-    return getNodeDetail(root.right, n, root, depth + 1);
+    ParentDepthPair leftPair = getParentDepthPair(root.left, val, currDepth + 1);
+    return leftPair != null ? leftPair : getParentDepthPair(root.right, val, currDepth + 1);
   }
   
-  private class NodeDetail {
+  private static class ParentDepthPair {
     TreeNode parent;
     int depth;
-
-    public NodeDetail(TreeNode parent, int depth) {
+    
+    public ParentDepthPair(TreeNode parent, int depth) {
       this.parent = parent;
       this.depth = depth;
     }

From c3e1068ddcfd392586a1362e3f8552dbf21b132c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 2 Sep 2022 14:05:42 -0700
Subject: [PATCH 1286/2175] Update Unique Email Addresses.java

---
 Easy/Unique Email Addresses.java | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/Easy/Unique Email Addresses.java b/Easy/Unique Email Addresses.java
index ca28017e..eb3da5d5 100644
--- a/Easy/Unique Email Addresses.java	
+++ b/Easy/Unique Email Addresses.java	
@@ -1,15 +1,13 @@
 class Solution {
   public int numUniqueEmails(String[] emails) {
-    return Arrays.stream(emails).map(Solution::formatEmail).collect(Collectors.toSet()).size();
+    return Arrays.stream(emails).map(Solution::getFormattedEmail).collect(Collectors.toSet()).size();
   }
 
-  private static String formatEmail(String email) {
-    String localName = email.split("@")[0];
-    return (localName.indexOf('+') != -1
-                ? localName.substring(0, localName.indexOf('+'))
-                : localName)
-            .replaceAll("\\.", "")
-        + "@"
-        + email.split("@")[1];
+  private static String getFormattedEmail(String email) {
+    String[] strs = email.split("@");
+    int plusIdx = strs[0].indexOf('+');
+    String formattedLocalName = strs[0].substring(0, (plusIdx == -1 ? strs[0].length() : plusIdx))
+        .replaceAll("\\.", "");
+    return formattedLocalName + "@" + strs[1];
   }
 }

From 6464d9d7cd451fa98fa56aec6efc5e1a04fba28b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 2 Sep 2022 14:12:22 -0700
Subject: [PATCH 1287/2175] Update Boats to Save People.java

---
 Medium/Boats to Save People.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Medium/Boats to Save People.java b/Medium/Boats to Save People.java
index 365bafc0..725f18c7 100644
--- a/Medium/Boats to Save People.java	
+++ b/Medium/Boats to Save People.java	
@@ -1,16 +1,16 @@
 class Solution {
   public int numRescueBoats(int[] people, int limit) {
     Arrays.sort(people);
+    int startIdx = 0;
+    int endIdx = people.length - 1;
     int count = 0;
-    int start = 0;
-    int end = people.length - 1;
-    while (end >= start) {
-      if (people[start] + people[end] <= limit) {
-        start++;
+    while (startIdx <= endIdx) {
+      int currWeight = people[endIdx--];
+      if (startIdx <= endIdx && currWeight + people[startIdx] <= limit) {
+        currWeight += people[startIdx++];
       }
-      end--;
       count++;
-    }
+    } 
     return count;
-  }
+  } 
 }

From 2052f493c6e0548cd76ec5d2af3e4a4e2f40ffc5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 2 Sep 2022 16:25:20 -0700
Subject: [PATCH 1288/2175] Update Count Univalue Subtrees.java

---
 Medium/Count Univalue Subtrees.java | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Medium/Count Univalue Subtrees.java b/Medium/Count Univalue Subtrees.java
index 2eae480a..73ac6599 100644
--- a/Medium/Count Univalue Subtrees.java	
+++ b/Medium/Count Univalue Subtrees.java	
@@ -15,27 +15,22 @@
  */
 class Solution {
   public int countUnivalSubtrees(TreeNode root) {
+    if (root == null) {
+      return 0;
+    }
     int[] count = {0};
-    helper(root, count);
+    helper(root, count, root.val);
     return count[0];
   }
   
-  private boolean helper(TreeNode root, int[] count) {
+  private boolean helper(TreeNode root, int[] count, int val) {
     if (root == null) {
       return true;
     }
-    boolean leftVal = helper(root.left, count);
-    boolean rightVal = helper(root.right, count);
-    if (leftVal && rightVal) {
-      if (
-        (root.left != null && root.left.val != root.val) || 
-        (root.right != null && root.right.val != root.val)
-      ) {
-        return false;
-      }
-      count[0]++;
-      return true;
+    if (!helper(root.left, count, root.val) | !helper(root.right, count, root.val)) {
+      return false;
     }
-    return false;
+    count[0]++;
+    return root.val == val;
   }
 }

From 9da58f43d7b6d1a2e122660de29dbcabb5c4347f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Sep 2022 13:00:34 -0700
Subject: [PATCH 1289/2175] Update Numbers With Same Consecutive
 Differences.java

---
 ...ers With Same Consecutive Differences.java | 38 ++++++++-----------
 1 file changed, 16 insertions(+), 22 deletions(-)

diff --git a/Medium/Numbers With Same Consecutive Differences.java b/Medium/Numbers With Same Consecutive Differences.java
index 24c35555..9c93c383 100644
--- a/Medium/Numbers With Same Consecutive Differences.java	
+++ b/Medium/Numbers With Same Consecutive Differences.java	
@@ -1,31 +1,25 @@
 class Solution {
-  public int[] numsSameConsecDiff(int N, int K) {
-    if (N == 1) {
-      return new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    }
-    Set<Integer> set = new HashSet<>();
-    for (int i = 1; i <= 9; i++) {
-      helper(i, new StringBuilder(), K, set, N);
-    }
-    int[] ans = new int[set.size()];
-    Iterator<Integer> iterator = set.iterator();
-    for (int i = 0; i < ans.length; i++) {
-      ans[i] = iterator.next();
-    }
-    return ans;
+  public int[] numsSameConsecDiff(int n, int k) {
+    List<Integer> result = new ArrayList<>();
+    helper(n, k, result, new StringBuilder());
+    return result.stream().mapToInt(Integer::intValue).toArray();
   }
 
-  private void helper(int curr, StringBuilder sb, int k, Set<Integer> set, int n) {
+  private void helper(int n, int k, List<Integer> result, StringBuilder sb) {
     if (sb.length() == n) {
-      set.add(Integer.parseInt(sb.toString()));
-    }
-    if (sb.length() > n || curr > 9 || curr < 0) {
+      result.add(Integer.parseInt(sb.toString()));
       return;
     }
-    else {
-      sb.append(curr);
-      helper(curr + k, sb, k, set, n);
-      helper(curr - k, sb, k, set, n);
+    for (int i = 0; i <= 9; i++) {
+      if (sb.isEmpty() && i == 0) {
+        continue;
+      }
+      if (!sb.isEmpty()
+          && Math.abs(Character.getNumericValue(sb.charAt(sb.length() - 1)) - i) != k) {
+        continue;
+      }
+      sb.append(i);
+      helper(n, k, result, new StringBuilder(sb));
       sb.deleteCharAt(sb.length() - 1);
     }
   }

From 089078d4557837b4a99f837b03070d76f33e1700 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Sep 2022 21:53:50 -0700
Subject: [PATCH 1290/2175] Update Vertical Order Traversal Of a Binary
 Tree.java

---
 ...ical Order Traversal Of a Binary Tree.java | 40 ++++++++++---------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/Hard/Vertical Order Traversal Of a Binary Tree.java b/Hard/Vertical Order Traversal Of a Binary Tree.java
index 8d00094a..2c82d9f6 100644
--- a/Hard/Vertical Order Traversal Of a Binary Tree.java	
+++ b/Hard/Vertical Order Traversal Of a Binary Tree.java	
@@ -15,42 +15,46 @@
  */
 class Solution {
   public List<List<Integer>> verticalTraversal(TreeNode root) {
-    Map<Integer, List<TreeCoordinate>> map = new TreeMap<>();
-    Queue<TreeCoordinate> queue = new LinkedList<>();
-    queue.add(new TreeCoordinate(root, 0, 0));
+    Map<Integer, List<NodePair>> map = new HashMap<>();
+    Queue<NodePair> queue = new LinkedList<>();
+    queue.add(new NodePair(0, 0, root));
+    int minColumn = 0;
+    int maxColumn = 0;
     while (!queue.isEmpty()) {
       int size = queue.size();
       while (size-- > 0) {
-        TreeCoordinate removed = queue.remove();
+        NodePair removed = queue.remove();
+        minColumn = Math.min(minColumn, removed.y);
+        maxColumn = Math.max(maxColumn, removed.y);
         map.computeIfAbsent(removed.y, k -> new ArrayList<>()).add(removed);
         if (removed.node.left != null) {
-          queue.add(new TreeCoordinate(removed.node.left, removed.x + 1, removed.y - 1));
+          queue.add(new NodePair(removed.x + 1, removed.y - 1, removed.node.left));
         }
         if (removed.node.right != null) {
-          queue.add(new TreeCoordinate(removed.node.right, removed.x + 1, removed.y + 1));
+          queue.add(new NodePair(removed.x + 1, removed.y + 1, removed.node.right));
         }
       }
     }
     List<List<Integer>> result = new ArrayList<>();
-    for (Integer key : map.keySet()) {
-      List<TreeCoordinate> temp = map.get(key);
-      Collections.sort(temp,
-          Comparator.comparingInt((TreeCoordinate o) -> o.x).thenComparingInt(o -> o.node.val));
-      result.add(temp.stream().map(a -> a.node.val).collect(Collectors.toList()));
+    for (int key = minColumn; key <= maxColumn; key++) {
+      List<NodePair> list = map.get(key);
+      result.add(list.stream()
+                 .sorted(Comparator.comparingInt((NodePair o) -> o.x).thenComparingInt(o -> o.node.val))
+                 .map(np -> np.node.val)
+                 .collect(Collectors.toList()));
     }
     return result;
   }
   
-  private static class TreeCoordinate {
+  class NodePair {
+    int x;
+    int y;
+    TreeNode node;
     
-    public TreeNode node;
-    public int x;
-    public int y;
-    
-    public TreeCoordinate(TreeNode node, int x, int y) {
-      this.node = node;
+    public NodePair(int x, int y, TreeNode node) {
       this.x = x;
       this.y = y;
+      this.node = node;
     }
   }
 }

From 25457f092966035d64bae8a308029698e48ad8c2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Sep 2022 21:58:30 -0700
Subject: [PATCH 1291/2175] Create Check Distances Between Same Letters.java

---
 Easy/Check Distances Between Same Letters.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Check Distances Between Same Letters.java

diff --git a/Easy/Check Distances Between Same Letters.java b/Easy/Check Distances Between Same Letters.java
new file mode 100644
index 00000000..ed5367f6
--- /dev/null
+++ b/Easy/Check Distances Between Same Letters.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public boolean checkDistances(String s, int[] distance) {
+    Map<Character, Integer> charToIdx = new HashMap<>();
+    for (int i = 0; i < s.length(); i++) {
+      if (charToIdx.containsKey(s.charAt(i))) {
+        int diff = i - charToIdx.get(s.charAt(i)) - 1;
+        if (diff != distance[s.charAt(i) - 'a']) {
+          return false;
+        }
+      } else {
+        charToIdx.put(s.charAt(i), i);
+      }
+    }
+    return true;
+  }
+}

From 354581b7b804c85c3097d1a8361b84001883568d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 4 Sep 2022 16:59:16 -0700
Subject: [PATCH 1292/2175] Create Find Subarrays With Equal Sum.java

---
 Easy/Find Subarrays With Equal Sum.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Find Subarrays With Equal Sum.java

diff --git a/Easy/Find Subarrays With Equal Sum.java b/Easy/Find Subarrays With Equal Sum.java
new file mode 100644
index 00000000..834989a0
--- /dev/null
+++ b/Easy/Find Subarrays With Equal Sum.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public boolean findSubarrays(int[] nums) {
+    Set<Integer> set = new HashSet<>();
+    for (int i = 0; i < nums.length - 1; i++) {
+      int sum = nums[i] + nums[i + 1];
+      if (set.contains(sum)) {
+        return true;
+      }
+      set.add(sum);
+    }
+    return false;
+  }
+}

From b6bed02c8d4ff81a0ac8399c8b765c54af595ae3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 4 Sep 2022 17:03:30 -0700
Subject: [PATCH 1293/2175] Update N-ary Tree Level Order Traversal.java

---
 Medium/N-ary Tree Level Order Traversal.java | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/Medium/N-ary Tree Level Order Traversal.java b/Medium/N-ary Tree Level Order Traversal.java
index 29373207..7f3df2b3 100644
--- a/Medium/N-ary Tree Level Order Traversal.java	
+++ b/Medium/N-ary Tree Level Order Traversal.java	
@@ -22,21 +22,19 @@ public List<List<Integer>> levelOrder(Node root) {
     if (root == null) {
       return new ArrayList<>();
     }
-    List<List<Integer>> result = new ArrayList<>();
+    List<List<Integer>> levels = new ArrayList<>();
     Queue<Node> queue = new LinkedList<>();
     queue.add(root);
     while (!queue.isEmpty()) {
       int size = queue.size();
-      List<Integer> level = new ArrayList<>();
+      List<Integer> currLevel = new ArrayList<>();
       while (size-- > 0) {
         Node removed = queue.remove();
-        level.add(removed.val);
-        for (Node child : removed.children) {
-          queue.add(child);
-        }
+        currLevel.add(removed.val);
+        queue.addAll(removed.children);
       }
-      result.add(level);
+      levels.add(currLevel);
     }
-    return result;
-  }
+    return levels;
+  }   
 }

From 89bf3963cffcaffa359d4f8494b35f0dd4205252 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 5 Sep 2022 07:29:02 -0700
Subject: [PATCH 1294/2175] Create Strictly Palindromic Number.java

---
 Medium/Strictly Palindromic Number.java | 32 +++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Strictly Palindromic Number.java

diff --git a/Medium/Strictly Palindromic Number.java b/Medium/Strictly Palindromic Number.java
new file mode 100644
index 00000000..b2e27e3a
--- /dev/null
+++ b/Medium/Strictly Palindromic Number.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public boolean isStrictlyPalindromic(int n) {
+    for (int i = 2; i <= n - 2; i++) {
+      if (!isPalindrome(convertToBase(n, i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  private String convertToBase(int n, int base) {
+    StringBuilder sb = new StringBuilder();
+    while (n > 0) {
+      sb.append(n % base);
+      n /= base;
+    }
+    return sb.reverse().toString();
+  }
+  
+  private boolean isPalindrome(String s) {
+    int start = 0;
+    int end = s.length() - 1;
+    while (start < end) {
+      if (s.charAt(start) != s.charAt(end)) {
+        return false;
+      }
+      start++;
+      end--;
+    }
+    return true;
+  }
+}

From a925b55250fbccf8070db1e3deccbccb14a8b7ad Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 5 Sep 2022 14:45:28 -0700
Subject: [PATCH 1295/2175] Update Maximum Product of three numbers.java

---
 Easy/Maximum Product of three numbers.java | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/Easy/Maximum Product of three numbers.java b/Easy/Maximum Product of three numbers.java
index ebc6f79b..981fbf96 100644
--- a/Easy/Maximum Product of three numbers.java	
+++ b/Easy/Maximum Product of three numbers.java	
@@ -2,9 +2,8 @@ class Solution {
   public int maximumProduct(int[] nums) {
     Arrays.sort(nums);
     int n = nums.length;
-    int rightSideProd = nums[n - 1] * nums[n - 2] * nums[n - 3];
-    int leftSideProd = nums[0] * nums[1] * nums[2];
-    int mixedSideProd = nums[0] * nums[1] * nums[n - 1];
-    return Math.max(rightSideProd, Math.max(leftSideProd, mixedSideProd));
+    int lastThree = nums[n - 1] * nums[n - 2] * nums[n - 3];
+    int firstTwoAndLast = nums[0] * nums[1] * nums[n - 1];
+    return Math.max(lastThree, firstTwoAndLast);
   }
 }

From 295a89272b0d954ad1145dea4f0074b8b86f7dc0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 5 Sep 2022 14:45:44 -0700
Subject: [PATCH 1296/2175] Rename Maximum Product of three numbers.java to
 Maximum Product of Three Numbers.java

---
 ...f three numbers.java => Maximum Product of Three Numbers.java} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename Easy/{Maximum Product of three numbers.java => Maximum Product of Three Numbers.java} (100%)

diff --git a/Easy/Maximum Product of three numbers.java b/Easy/Maximum Product of Three Numbers.java
similarity index 100%
rename from Easy/Maximum Product of three numbers.java
rename to Easy/Maximum Product of Three Numbers.java

From 560256d22b9ff47693370f0a6c53217065e78ab0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 5 Sep 2022 19:21:23 -0700
Subject: [PATCH 1297/2175] Update Binary Tree Pruning.java

---
 Medium/Binary Tree Pruning.java | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/Medium/Binary Tree Pruning.java b/Medium/Binary Tree Pruning.java
index a03af5a7..9269db06 100644
--- a/Medium/Binary Tree Pruning.java	
+++ b/Medium/Binary Tree Pruning.java	
@@ -15,23 +15,21 @@
  */
 class Solution {
   public TreeNode pruneTree(TreeNode root) {
-    boolean isRootOne = helper(root);
-    return isRootOne ? root : null;
+    return subtreeContainsOne(root) ? root : null;
   }
   
-  private boolean helper(TreeNode root) {
+  private boolean subtreeContainsOne(TreeNode root) {
     if (root == null) {
       return false;
     }
-    boolean selfOne = root.val == 1;
-    boolean leftContainsOne = helper(root.left);
-    boolean rightContainsOne = helper(root.right);
-    if (!leftContainsOne) {
+    boolean leftContains = subtreeContainsOne(root.left);
+    boolean rightContains = subtreeContainsOne(root.right);
+    if (!leftContains) {
       root.left = null;
     }
-    if (!rightContainsOne) {
+    if (!rightContains) {
       root.right = null;
     }
-    return selfOne || leftContainsOne || rightContainsOne;
+    return leftContains || rightContains || root.val == 1;
   }
 }

From fc59cb84f7af6ea975c66da7dc638ad22a8cb9ce Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 6 Sep 2022 07:43:06 -0700
Subject: [PATCH 1298/2175] Update Reorganize String.java

---
 Medium/Reorganize String.java | 69 ++++++++++++++++-------------------
 1 file changed, 31 insertions(+), 38 deletions(-)

diff --git a/Medium/Reorganize String.java b/Medium/Reorganize String.java
index 824bc88b..f3c2dfc1 100644
--- a/Medium/Reorganize String.java	
+++ b/Medium/Reorganize String.java	
@@ -1,44 +1,37 @@
 class Solution {
-    public String reorganizeString(String S) {
-        int buffer = S.length()%2 == 0 ? S.length()/2 : S.length()/2 + 1;
-        Map<Character, Integer> map = new HashMap<>();
-        char[] chars = S.toCharArray();
-
-        for (char c : chars) {
-            map.put(c, map.getOrDefault(c, 0) + 1);
-            if (map.get(c) > buffer) {
-                return "";
-            }
-        }
-
-        return createString(map);
+  public String reorganizeString(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      map.put(c, map.getOrDefault(c, 0) + 1);
     }
-
-    private String createString(Map<Character, Integer> map) {
-        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> b[1] - a[1]);
-        for (char c : map.keySet()) {
-            pq.add(new int[] {c, map.get(c)});
-        }
-
-        StringBuilder sb = new StringBuilder();
-        while (!pq.isEmpty()) {
-            int[] first = pq.poll();
-            if (sb.length() == 0 || first[0] != sb.charAt(sb.length() - 1)) {
-                sb.append((char) first[0]);
-                if (--first[1] > 0) {
-                    pq.add(first);
-                }
-            }
-            else {
-                int[] second = pq.poll();
-                sb.append((char) second[0]);
-                if (--second[1] > 0) {
-                    pq.add(second);
-                }
-                pq.add(first);
-            }
+    PriorityQueue<Character> pq = new PriorityQueue<>(
+        (o1, o2) -> map.get(o2).compareTo(map.get(o1)));
+    pq.addAll(map.keySet());
+    StringBuilder sb = new StringBuilder();
+    while (!pq.isEmpty()) {
+      char removed = pq.poll();
+      if (!sb.isEmpty() && sb.charAt(sb.length() - 1) == removed) {
+        if (pq.isEmpty()) {
+          return "";
         }
+        char secondRemoved = pq.poll();
+        pq.add(removed);
+        sb.append(secondRemoved);
+        updateStructure(map, pq, secondRemoved);
+      } else {
+        sb.append(removed);
+        updateStructure(map, pq, removed);
+      }
+    }
+    return sb.toString();
+  }
 
-        return sb.toString();
+  private void updateStructure(Map<Character, Integer> map, PriorityQueue<Character> pq, char c) {
+    map.put(c, map.get(c) - 1);
+    if (map.get(c) > 0) {
+      pq.add(c);
+    } else {
+      map.remove(c);
     }
+  }
 }

From 9e2e25843b5a2d4800136229318b660e2363f7ac Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 6 Sep 2022 08:33:20 -0700
Subject: [PATCH 1299/2175] Create Maximum Length of Repeated Subarray.java

---
 Medium/Maximum Length of Repeated Subarray.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Maximum Length of Repeated Subarray.java

diff --git a/Medium/Maximum Length of Repeated Subarray.java b/Medium/Maximum Length of Repeated Subarray.java
new file mode 100644
index 00000000..af6696fb
--- /dev/null
+++ b/Medium/Maximum Length of Repeated Subarray.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int findLength(int[] nums1, int[] nums2) {
+    int result = 0;
+    int[][] dp = new int[nums1.length + 1][nums2.length + 1];
+    for (int i = nums1.length - 1; i >= 0; i--) {
+      for (int j = nums2.length - 1; j >= 0; j--) {
+        if (nums1[i] == nums2[j]) {
+          dp[i][j] = dp[i + 1][j + 1] + 1;
+          result = Math.max(result, dp[i][j]);
+        }
+      }
+    }
+    return result;
+  }
+}

From 70600a3f2a119317846b10820f9541b42eb3b83f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 6 Sep 2022 10:53:15 -0700
Subject: [PATCH 1300/2175] Update Longest Harmonious Subsequence.java

---
 Easy/Longest Harmonious Subsequence.java | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/Easy/Longest Harmonious Subsequence.java b/Easy/Longest Harmonious Subsequence.java
index 97d0ec4a..73f54d43 100644
--- a/Easy/Longest Harmonious Subsequence.java	
+++ b/Easy/Longest Harmonious Subsequence.java	
@@ -1,13 +1,16 @@
 class Solution {
   public int findLHS(int[] nums) {
-    Map<Integer, Long> map = Arrays.stream(nums).boxed()
-        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
-    int result = 0;
-    for (Integer key : map.keySet()) {
-      if (map.containsKey(key + 1)) {
-        result = Math.max(result, (int) (map.get(key) + map.get(key + 1)));
+    int maxSubarraySize = 0;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+      if (map.containsKey(num + 1)) {
+        maxSubarraySize = Math.max(maxSubarraySize, map.get(num) + map.get(num + 1));
+      }
+      if (map.containsKey(num - 1)) {
+        maxSubarraySize = Math.max(maxSubarraySize, map.get(num) + map.get(num - 1));
       }
     }
-    return result;
+    return maxSubarraySize;
   }
 }

From 41ffff1f70b7d7e8856b41e08ff6ae02b527793b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 6 Sep 2022 18:34:02 -0700
Subject: [PATCH 1301/2175] Update Construct String from Binary Tree.java

---
 Easy/Construct String from Binary Tree.java | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Easy/Construct String from Binary Tree.java b/Easy/Construct String from Binary Tree.java
index be38ff5e..a6b1a205 100644
--- a/Easy/Construct String from Binary Tree.java	
+++ b/Easy/Construct String from Binary Tree.java	
@@ -14,26 +14,26 @@
  * }
  */
 class Solution {
-  public String tree2str(TreeNode t) {
+  public String tree2str(TreeNode root) {
     StringBuilder sb = new StringBuilder();
-    helper(t, sb);
+    helper(root, sb);
     return sb.toString();
   }
   
-  private void helper(TreeNode node, StringBuilder sb) {
-    if (node == null) {
+  private void helper(TreeNode root, StringBuilder sb) {
+    if (root == null) {
       return;
     }
-    sb.append(node.val);
-    if (node.left == null && node.right == null) {
+    sb.append(root.val);
+    if (root.left == null && root.right == null) {
       return;
     }
     sb.append("(");
-    helper(node.left, sb);
+    helper(root.left, sb);
     sb.append(")");
-    if (node.right != null) {
+    if (root.right != null) {
       sb.append("(");
-      helper(node.right, sb);
+      helper(root.right, sb);
       sb.append(")");
     }
   }

From 58878fda3aedabe514bd1c6239c545d393a590b6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Sep 2022 06:52:14 -0700
Subject: [PATCH 1302/2175] Update Koko Eating Bananas.java

---
 Medium/Koko Eating Bananas.java | 37 +++++++++++++--------------------
 1 file changed, 15 insertions(+), 22 deletions(-)

diff --git a/Medium/Koko Eating Bananas.java b/Medium/Koko Eating Bananas.java
index e4bab284..821a21ca 100644
--- a/Medium/Koko Eating Bananas.java	
+++ b/Medium/Koko Eating Bananas.java	
@@ -1,33 +1,26 @@
 class Solution {
   public int minEatingSpeed(int[] piles, int h) {
-    int minBananaCount = 1;
-    int maxBananaCount = maxFromPile(piles);
-    while (minBananaCount < maxBananaCount) {
-      int mid = (minBananaCount + maxBananaCount) / 2;
-      if (canFinishPile(piles, mid, h)) {
-        maxBananaCount = mid;
+    int start = 1;
+    int end = 0;
+    for (int pile : piles) {
+      end = Math.max(end, pile);
+    }
+    while (start <= end) {
+      int mid = start + (end - start) / 2;
+      if (isPossible(piles, mid, h)) {
+        end = mid - 1;
       } else {
-        minBananaCount = mid + 1;
+        start = mid + 1;
       }
     }
-    return minBananaCount;
+    return start;
   }
   
-  private boolean canFinishPile(int[] piles, int bananaPerHour, int totalHours) {
-    int totalTime = 0;
+  private boolean isPossible(int[] piles, int k, int h) {
+    int numOfHours = 0;
     for (int pile : piles) {
-      int numOfHours = pile / bananaPerHour; 
-      totalTime += numOfHours == 0 ? 1 : numOfHours;
-      totalTime += numOfHours > 0 && pile % bananaPerHour != 0 ? 1 : 0;
-    }
-    return totalTime <= totalHours;
-  }
-  
-  private int maxFromPile(int[] piles) {
-    int maxCount = piles[0];
-    for (int i = 1; i < piles.length; i++) {
-      maxCount = Math.max(maxCount, piles[i]);
+      numOfHours += Math.ceil((double) pile / k);
     }
-    return maxCount;
+    return numOfHours <= h;
   }
 }

From 6a4ed92bae9bb89eff2b2d05129d01d9d929f0c0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Sep 2022 07:33:11 -0700
Subject: [PATCH 1303/2175] Update Product of the Last K Numbers.java

---
 Medium/Product of the Last K Numbers.java | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/Medium/Product of the Last K Numbers.java b/Medium/Product of the Last K Numbers.java
index 9eda5d06..acfc5bae 100644
--- a/Medium/Product of the Last K Numbers.java	
+++ b/Medium/Product of the Last K Numbers.java	
@@ -1,21 +1,24 @@
 class ProductOfNumbers {
-  List<Integer> list;
+
+  private List<Integer> list;
+  
   public ProductOfNumbers() {
+    this.list = new ArrayList<>();
     add(0);
   }
 
   public void add(int num) {
     if (num > 0) {
       list.add(list.get(list.size() - 1) * num);
-    }
-    else {
+    } else {
       list = new ArrayList<>();
       list.add(1);
     }
   }
 
   public int getProduct(int k) {
-    return k < list.size() ? list.get(list.size() - 1) / list.get(list.size() - k - 1) : 0;
+    int n = list.size();
+    return k < n ? list.get(n - 1) / list.get(n - k - 1) : 0;
   }
 }
 

From b1c3edd9496a7cc3c750a6d1a6045666de37dc3c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Sep 2022 11:05:08 -0700
Subject: [PATCH 1304/2175] Update Decode String.java

---
 Medium/Decode String.java | 46 +++++++++++++++++++--------------------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/Medium/Decode String.java b/Medium/Decode String.java
index f88449d7..fb2f81de 100644
--- a/Medium/Decode String.java	
+++ b/Medium/Decode String.java	
@@ -1,34 +1,32 @@
 class Solution {
   public String decodeString(String s) {
-    Stack<Integer> countStack = new Stack<>();
-    Stack<String> wordStack = new Stack<>();
-    StringBuilder sb = new StringBuilder();
-    int idx = 0;
-    while (idx < s.length()) {
-      if (Character.isDigit(s.charAt(idx))) {
-        int count = 0;
-        while (idx < s.length() && Character.isDigit(s.charAt(idx))) {
-          count = count * 10 + Character.getNumericValue(s.charAt(idx++));
+    Stack<Character> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
+      if (c == ']') {
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty() && stack.peek() != '[') {
+          sb.append(stack.pop());
         }
-        countStack.push(count);
-      } else if (Character.isLetter(s.charAt(idx))) {
-        sb.append(s.charAt(idx++));
-      } else if (s.charAt(idx) == '[') {
-        wordStack.push(sb.toString());
-        sb.setLength(0);
-        idx++;
-      } else {
-        StringBuilder temp = new StringBuilder(wordStack.pop());
-        String currentString = sb.toString();
+        stack.pop();
+        String temp = sb.toString();
         sb.setLength(0);
-        int count = countStack.pop();
+        while (!stack.isEmpty() && Character.isDigit(stack.peek())) {
+          sb.append(stack.pop());
+        }
+        int count = Integer.parseInt(sb.reverse().toString());
         while (count-- > 0) {
-          temp.append(currentString);
+          for (int i = temp.length() - 1; i >= 0; i--) {
+            stack.push(temp.charAt(i));
+          }
         }
-        sb.append(temp);
-        idx++;
+      } else {
+        stack.push(c);
       }
     }
-    return sb.toString();
+    StringBuilder sb = new StringBuilder();
+    while (!stack.isEmpty()) {
+      sb.append(stack.pop());
+    }
+    return sb.reverse().toString();
   }
 }

From 73a4840d7e722a1dba15ab434e71c3db77810796 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Sep 2022 14:31:47 -0700
Subject: [PATCH 1305/2175] Update Valid Sudoku.java

---
 Medium/Valid Sudoku.java | 47 +++++++++++++++++++++-------------------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/Medium/Valid Sudoku.java b/Medium/Valid Sudoku.java
index e35dd7c3..88538727 100644
--- a/Medium/Valid Sudoku.java	
+++ b/Medium/Valid Sudoku.java	
@@ -1,27 +1,30 @@
 class Solution {
-    public boolean isValidSudoku(char[][] board) {
-        HashSet<Character>[] rowSet = new HashSet[9];
-        HashSet<Character>[] colSet = new HashSet[9];
-        HashSet<Character>[] boxSet = new HashSet[9];
-        for (int i = 0; i < 9; i++) {
-            rowSet[i] = new HashSet<>();
-            colSet[i] = new HashSet<>();
-            boxSet[i] = new HashSet<>();
+  public boolean isValidSudoku(char[][] board) {
+    int N = 9;
+    int[][] rows = new int[N][N];
+    int[][] cols = new int[N][N];
+    int[][] boxes = new int[N][N];
+    for (int r = 0; r < N; r++) {
+      for (int c = 0; c < N; c++) {
+        if (board[r][c] == '.') {
+          continue;
         }
-        for (int i = 0; i < 9; i++) {
-            for (int j = 0; j < 9; j++) {
-                if (board[i][j] != '.') {
-                    char val = board[i][j];
-                    int boxIdx = (i / 3) * 3 + j / 3;
-                    if (rowSet[i].contains(val) || colSet[j].contains(val) || boxSet[boxIdx].contains(val)) {
-                        return false;
-                    }
-                    rowSet[i].add(val);
-                    colSet[j].add(val);
-                    boxSet[boxIdx].add(val);
-                }
-            }
+        int pos = board[r][c] - '1';
+        if (rows[r][pos] == 1) {
+          return false;
         }
-        return true;
+        rows[r][pos] = 1;
+        if (cols[c][pos] == 1) {
+          return false;
+        }
+        cols[c][pos] = 1;
+        int idx = (r / 3) * 3 + c / 3;
+        if (boxes[idx][pos] == 1) {
+          return false;
+        }
+        boxes[idx][pos] = 1;
+      }
     }
+    return true;
+  }
 }

From 31db170a118a3ed3be72157e6ace70dc332d99c9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Sep 2022 15:21:59 -0700
Subject: [PATCH 1306/2175] Update Find Median From Data Stream.java

---
 Hard/Find Median From Data Stream.java | 27 ++++++++++++--------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/Hard/Find Median From Data Stream.java b/Hard/Find Median From Data Stream.java
index a62a5e96..7d0de21f 100644
--- a/Hard/Find Median From Data Stream.java	
+++ b/Hard/Find Median From Data Stream.java	
@@ -1,29 +1,26 @@
 class MedianFinder {
 
-  /** initialize your data structure here. */
-  PriorityQueue<Integer> smaller;
-  PriorityQueue<Integer> bigger;
+  private PriorityQueue<Integer> small;
+  private PriorityQueue<Integer> large;
+  
   public MedianFinder() {
-    smaller = new PriorityQueue<>((a, b) -> b - a);
-    bigger = new PriorityQueue<>();
+    this.small = new PriorityQueue<>((a, b) -> b - a);
+    this.large = new PriorityQueue<>();
   }
 
   public void addNum(int num) {
-    smaller.add(num);
-    bigger.add(smaller.poll());
-    if (smaller.size() < bigger.size()) {
-        smaller.add(bigger.poll());
+    small.add(num);
+    large.add(small.remove());
+    if (large.size() > small.size()) {
+      small.add(large.remove());
     }
   }
 
   public double findMedian() {
-    if (smaller.size() == 0 && bigger.size() == 0) {
-      return 0.0;
+    if (small.size() > large.size()) {
+      return small.peek();
     }
-    if (smaller.size() > bigger.size()) {
-      return (double) smaller.peek();
-    }
-    return ((double) smaller.peek() + bigger.peek()) / 2;
+    return (small.peek() + large.peek()) / 2.0;
   }
 }
 

From 601f7f4225f451ccf53d1199ae2afe9be3c41121 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Sep 2022 15:22:20 -0700
Subject: [PATCH 1307/2175] Rename Find Median From Data Stream.java to Find
 Median from Data Stream.java

---
 ...an From Data Stream.java => Find Median from Data Stream.java} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename Hard/{Find Median From Data Stream.java => Find Median from Data Stream.java} (100%)

diff --git a/Hard/Find Median From Data Stream.java b/Hard/Find Median from Data Stream.java
similarity index 100%
rename from Hard/Find Median From Data Stream.java
rename to Hard/Find Median from Data Stream.java

From 02ac83819a89fee90e309aac22e345cedcc187c1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Sep 2022 19:02:14 -0700
Subject: [PATCH 1308/2175] Update Binary Tree Inorder Traversal.java

---
 Easy/Binary Tree Inorder Traversal.java | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/Easy/Binary Tree Inorder Traversal.java b/Easy/Binary Tree Inorder Traversal.java
index aad98c4b..d17cf649 100644
--- a/Easy/Binary Tree Inorder Traversal.java	
+++ b/Easy/Binary Tree Inorder Traversal.java	
@@ -15,26 +15,24 @@
  */
 class Solution {
   public List<Integer> inorderTraversal(TreeNode root) {
-    List<Integer> list = new ArrayList<>();
     if (root == null) {
-      return list;
+      return List.of();
     }
     Stack<TreeNode> stack = new Stack<>();
-    stack.push(root);
-    root = root.left;
     while (root != null) {
       stack.push(root);
       root = root.left;
     }
+    List<Integer> result = new ArrayList<>();
     while (!stack.isEmpty()) {
       TreeNode removed = stack.pop();
-      list.add(removed.val);
-      removed = removed.right;
-      while (removed != null) {
-        stack.push(removed);
-        removed = removed.left;
+      result.add(removed.val);
+      TreeNode rightNode = removed.right;
+      while (rightNode != null) {
+        stack.push(rightNode);
+        rightNode = rightNode.left;
       }
     }
-    return list;
+    return result;
   }
 }

From 0a4d2c6ddfbef697b602fae32b17c2f6f3005a34 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Sep 2022 07:01:09 -0700
Subject: [PATCH 1309/2175] Update Reverse Nodes in k-Group.java

---
 Hard/Reverse Nodes in k-Group.java | 55 +++++++++++++-----------------
 1 file changed, 24 insertions(+), 31 deletions(-)

diff --git a/Hard/Reverse Nodes in k-Group.java b/Hard/Reverse Nodes in k-Group.java
index 66ab4ec1..f28071ac 100644
--- a/Hard/Reverse Nodes in k-Group.java	
+++ b/Hard/Reverse Nodes in k-Group.java	
@@ -10,47 +10,40 @@
  */
 class Solution {
   public ListNode reverseKGroup(ListNode head, int k) {
-    if (head == null) {
-      return null;
-    }
-    ListNode start = head;
-    ListNode curr = head;
+    ListNode newHead = null;
     ListNode prev = null;
-    ListNode revHead = null;
+    ListNode curr = head;
     while (curr != null) {
-      int count = 1;
-      while (curr.next != null && count < k) {
+      ListNode start = curr;
+      int idx = 1;
+      for (idx = 1; idx < k && curr.next != null; idx++) {
         curr = curr.next;
-        count++;
       }
-      if (count == k) {
-        ListNode next = curr.next;
-        curr.next = null;
-        if (revHead == null) {
-          revHead = curr;
-        }
-        ListNode reverse = reverse(start);
-        if (prev != null) {
-          prev.next = reverse;
-        }
-        start.next = next;
-        prev = start;
-        start = next;
-        curr = next;
+      if (idx != k) {
+        curr = null;
+        continue;
       }
-      else {
-        curr = curr.next;
+      ListNode next = curr.next;
+      curr.next = null;
+      ListNode reversedNode = reverse(start);
+      if (newHead == null) {
+        newHead = reversedNode;
       }
+      if (prev != null) {
+        prev.next = reversedNode;
+      }
+      prev = start;
+      start.next = next;
+      curr = next;
     }
-    return revHead == null ? head : revHead;
-  } 
+    return newHead;
+  }
   
-  private ListNode reverse(ListNode root) {
-    ListNode curr = root;
-    ListNode next = null;
+  private ListNode reverse(ListNode node) {
+    ListNode curr = node;
     ListNode prev = null;
     while (curr != null) {
-      next = curr.next;
+      ListNode next = curr.next;
       curr.next = prev;
       prev = curr;
       curr = next;

From ef5b3258830d62de77277059531caf9bd53d87ff Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Sep 2022 07:34:45 -0700
Subject: [PATCH 1310/2175] Update Basic Calculator.java

---
 Hard/Basic Calculator.java | 42 ++++++++++++++------------------------
 1 file changed, 15 insertions(+), 27 deletions(-)

diff --git a/Hard/Basic Calculator.java b/Hard/Basic Calculator.java
index a3d9b119..1a1813d0 100644
--- a/Hard/Basic Calculator.java	
+++ b/Hard/Basic Calculator.java	
@@ -1,41 +1,29 @@
 class Solution {
-  public static  int calculate(String s) {
+  public int calculate(String s) {
     Stack<Integer> stack = new Stack<>();
-    int res = 0;
-    int num = 0;
+    int result = 0;
+    int number = 0;
     int sign = 1;
-    boolean hasNumberStarted = false;
     for (int i = 0; i < s.length(); i++) {
       char c = s.charAt(i);
       if (Character.isDigit(c)) {
-        hasNumberStarted = true;
-        num = num * 10 + (int) (c - '0');
-      } else if (c == '+' && hasNumberStarted) {
-        hasNumberStarted = false;
-        res += sign * num;
-        num = 0;
-        sign = 1;
-      } else if (c == '-') {
-        if(!hasNumberStarted) {
-          sign *= -1;
-          continue;
-        }
-        hasNumberStarted = false;
-        res += sign * num;
-        num = 0;
-        sign = -1;
+        number = number * 10 + Character.getNumericValue(c);
+      } else if (c == '+' || c == '-') {
+        result += sign * number;
+        sign = c == '+' ? 1 : -1;
+        number = 0;
       } else if (c == '(') {
-        stack.push(res);
+        stack.push(result);
         stack.push(sign);
         sign = 1;
-        res = 0;
+        result = 0;
       } else if (c == ')') {
-        res += sign * num;
-        num = 0;
-        res *= stack.pop(); // For sign
-        res += stack.pop(); // Adding the num in stack
+        result += sign * number;
+        result *= stack.pop();
+        result += stack.pop();
+        number = 0;
       }
     }
-    return res + (num != 0 ? sign * num : 0);
+    return result + (sign * number);
   }
 }

From d8655be27c206f4ef78a011a813e647fd538f536 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Sep 2022 15:53:28 -0700
Subject: [PATCH 1311/2175] Update Basic Calculator III.java

---
 Hard/Basic Calculator III.java | 94 +++++++++-------------------------
 1 file changed, 24 insertions(+), 70 deletions(-)

diff --git a/Hard/Basic Calculator III.java b/Hard/Basic Calculator III.java
index ab8af16e..dd97e966 100644
--- a/Hard/Basic Calculator III.java	
+++ b/Hard/Basic Calculator III.java	
@@ -1,74 +1,28 @@
 class Solution {
-    public int calculate(String s) {
-        if (s.length() == 0) {
-            return 0;
+  public int calculate(String s) {
+    int currNum = 0;
+    int prevNum = 0;
+    int result = 0;
+    char operation = '+';
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (Character.isDigit(c)) {
+        currNum = currNum * 10 + Character.getNumericValue(c);
+      } 
+      if ((!Character.isDigit(c) && !Character.isWhitespace(c)) || i == s.length() - 1) {
+        if (operation == '-' || operation == '+') {
+          result += prevNum;
+          prevNum = operation == '+' ? currNum : -currNum;
+        } else if (operation == '*') {
+          prevNum = prevNum * currNum;
+        } else {
+          prevNum = prevNum / currNum;
         }
-        
-        Stack<Integer> nums = new Stack<>();
-        Stack<Character> ops = new Stack<>();
-        int num = 0;
-        
-        for (int i = 0; i < s.length(); i++) {
-            char c = s.charAt(i);
-            if (c == ' ') {
-                continue;
-            }
-            
-            if (Character.isDigit(c)) {
-                num = c - '0';
-                while (i < s.length() - 1 && Character.isDigit(s.charAt(i + 1))) {
-                    num = num * 10 + (s.charAt(i + 1) - '0');
-                    i++;
-                }
-                
-                nums.push(num);
-                num = 0;
-            }
-            else if (c == '(') {
-                ops.push(c);
-            }
-            else if (c == ')') {
-                while (ops.peek() != '(') {
-                    nums.push(performOperation(ops.pop(), nums.pop(), nums.pop()));
-                }
-                ops.pop();
-            }
-            else if (c == '+' || c == '-' || c == '*' || c == '/') {
-                while (!ops.isEmpty() && precedence(c, ops.peek())) {
-                    nums.push(performOperation(ops.pop(), nums.pop(), nums.pop()));
-                }
-                
-                ops.push(c);
-            }
-        }
-        
-        while (!ops.isEmpty()) {
-            nums.push(performOperation(ops.pop(), nums.pop(), nums.pop()));
-        }
-        
-        return nums.pop();
-    }
-    
-    private int performOperation(char op, int b, int a) {
-        switch (op) {
-            case '+': return a + b;
-            case '-': return a - b;
-            case '*': return a * b;
-            case '/': return a / b;
-        }
-        
-        return 0;
-    }
-    
-    private boolean precedence(char op1, char op2) {
-        if (op2 == '(' || op2 == ')') {
-            return false;
-        }
-        
-        if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-')) {
-            return false;
-        }
-        
-        return true;
+        operation = c;
+        currNum = 0;
+      }
     }
+    result += prevNum;
+    return result;
+  }
 }

From ab71ab7fc99b4b63d8759b4b05216209e86372b2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Sep 2022 15:54:06 -0700
Subject: [PATCH 1312/2175] Update Basic Calculator II.java

---
 Medium/Basic Calculator II.java | 47 ++++++++++++---------------------
 1 file changed, 17 insertions(+), 30 deletions(-)

diff --git a/Medium/Basic Calculator II.java b/Medium/Basic Calculator II.java
index 402e394c..dd97e966 100644
--- a/Medium/Basic Calculator II.java	
+++ b/Medium/Basic Calculator II.java	
@@ -1,41 +1,28 @@
 class Solution {
   public int calculate(String s) {
-    char sign = '+';
     int currNum = 0;
-    Stack<Integer> stack = new Stack<>();
+    int prevNum = 0;
+    int result = 0;
+    char operation = '+';
     for (int i = 0; i < s.length(); i++) {
-      if (Character.isDigit(s.charAt(i))) {
-        currNum = currNum * 10 + Character.getNumericValue(s.charAt(i));
+      char c = s.charAt(i);
+      if (Character.isDigit(c)) {
+        currNum = currNum * 10 + Character.getNumericValue(c);
       } 
-      if ((!Character.isDigit(s.charAt(i)) && s.charAt(i) != ' ') || i == s.length() - 1) {
-        updateStackForPreviousSign(sign, stack, currNum);
+      if ((!Character.isDigit(c) && !Character.isWhitespace(c)) || i == s.length() - 1) {
+        if (operation == '-' || operation == '+') {
+          result += prevNum;
+          prevNum = operation == '+' ? currNum : -currNum;
+        } else if (operation == '*') {
+          prevNum = prevNum * currNum;
+        } else {
+          prevNum = prevNum / currNum;
+        }
+        operation = c;
         currNum = 0;
-        sign = s.charAt(i);
       }
     }
-    int result = 0;
-    while (!stack.isEmpty()) {
-      result += stack.pop();
-    }
+    result += prevNum;
     return result;
   }
-
-  private void updateStackForPreviousSign(char sign, Stack<Integer> stack, int currNum) {
-    switch (sign) {
-      case '+':
-        stack.push(currNum);
-        break;
-      case '-':
-        stack.push(-1 * currNum);
-        break;
-      case '/':
-        stack.push(stack.pop() / currNum);
-        break;
-      case '*':
-        stack.push(stack.pop() * currNum);
-        break;
-      default:
-        break;
-    }
-  }
 }

From 5c50a3202197304d9e4390774f33af2d03c058e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 9 Sep 2022 07:16:23 -0700
Subject: [PATCH 1313/2175] Create The Number of Weak Characters in the
 Game.java

---
 ...Number of Weak Characters in the Game.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/The Number of Weak Characters in the Game.java

diff --git a/Medium/The Number of Weak Characters in the Game.java b/Medium/The Number of Weak Characters in the Game.java
new file mode 100644
index 00000000..18607097
--- /dev/null
+++ b/Medium/The Number of Weak Characters in the Game.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public int numberOfWeakCharacters(int[][] properties) {
+    int maxAttackValue = 0;
+    for (int[] property : properties) {
+      maxAttackValue = Math.max(maxAttackValue, property[0]);
+    }
+    int maxDefense[] = new int[maxAttackValue + 2];
+    for (int[] property : properties) {
+      int attack = property[0];
+      int defense = property[1];
+      maxDefense[attack] = Math.max(maxDefense[attack], defense);
+    }
+    for (int i = maxAttackValue - 1; i >= 0; i--) {
+      maxDefense[i] = Math.max(maxDefense[i], maxDefense[i + 1]);
+    }
+    int count = 0;
+    for (int[] property : properties) {
+      int attack = property[0];
+      int defense = property[1]; 
+      if (defense < maxDefense[attack + 1]) {
+        count++;
+      }
+    }
+    return count;
+  }
+}

From bd9598f7ed8a6b85cb01322c9bcf0e0fe344f060 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 9 Sep 2022 10:25:09 -0700
Subject: [PATCH 1314/2175] Update Goat Latin.java

---
 Easy/Goat Latin.java | 38 ++++++++++++++------------------------
 1 file changed, 14 insertions(+), 24 deletions(-)

diff --git a/Easy/Goat Latin.java b/Easy/Goat Latin.java
index 56c98048..83417b2f 100644
--- a/Easy/Goat Latin.java	
+++ b/Easy/Goat Latin.java	
@@ -1,29 +1,19 @@
 class Solution {
-  public String toGoatLatin(String S) {
-    StringBuilder sb = new StringBuilder();
-    StringBuilder endAppend = new StringBuilder("a");
-    final String CONSTANT_APPEND = "ma";
-    int start = 0;
-    int end = 0;
-    int n = S.length();
-    while (end < n) {
-      while (end < n && S.charAt(end) != ' ') {
-        end++;
-      }
-      char c = Character.toLowerCase(S.charAt(start));
-      if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
-        sb.append(S.substring(start, end)).append(CONSTANT_APPEND).append(endAppend.toString());
-      }
-      else {
-        sb.append(S.substring(start + 1, end)).append(S.charAt(start)).append(CONSTANT_APPEND).append(endAppend.toString());
-      }
-      endAppend.append('a');
-      end++;
-      start = end;
-      if (end < n) {
-        sb.append(' ');
+  public String toGoatLatin(String sentence) {
+    String[] words = sentence.split("\\s+");
+    StringBuilder result = new StringBuilder();
+    StringBuilder aWord = new StringBuilder();
+    Set<Character> vowels = Set.of('a', 'e', 'i', 'o', 'u');
+    for (String word : words) {
+      aWord.append('a');
+      char firstChar = word.charAt(0);
+      if (vowels.contains(Character.toLowerCase(firstChar))) {
+        result.append(word).append("ma");
+      } else {
+        result.append(word.substring(1)).append(firstChar).append("ma");
       }
+      result.append(aWord.toString()).append(" ");
     }
-    return sb.toString();
+    return result.toString().trim();
   }
 }

From b89443509ab0b984a78458bc659cfd26b8e9bff6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 9 Sep 2022 10:25:48 -0700
Subject: [PATCH 1315/2175] Update Fraction to Recurring Decimal.java

---
 Medium/Fraction to Recurring Decimal.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Medium/Fraction to Recurring Decimal.java b/Medium/Fraction to Recurring Decimal.java
index 8e0385ba..dda64d6b 100644
--- a/Medium/Fraction to Recurring Decimal.java	
+++ b/Medium/Fraction to Recurring Decimal.java	
@@ -4,22 +4,22 @@ public String fractionToDecimal(int numerator, int denominator) {
       return "0";
     }
     StringBuilder fraction = new StringBuilder();
-    if (numerator < 0 ^ denominator < 0) {
-      fraction.append("-");
+    if ((numerator < 0 && denominator > 0) || (numerator > 0 && denominator < 0)) {
+      fraction.append('-');
     }
-    long dividend = Math.abs((long) numerator);
-    long divisor = Math.abs((long) denominator);
+    long dividend = Math.abs(Long.valueOf(numerator));
+    long divisor = Math.abs(Long.valueOf(denominator));
     fraction.append(String.valueOf(dividend / divisor));
     long remainder = dividend % divisor;
     if (remainder == 0) {
       return fraction.toString();
     }
-    fraction.append(".");
+    fraction.append('.');
     Map<Long, Integer> map = new HashMap<>();
     while (remainder != 0) {
       if (map.containsKey(remainder)) {
         fraction.insert(map.get(remainder), "(");
-        fraction.append(")");
+        fraction.append(')');
         break;
       }
       map.put(remainder, fraction.length());

From ca9ae14899dadf42039436179aab62e1eaa20807 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 9 Sep 2022 11:47:38 -0700
Subject: [PATCH 1316/2175] Update Sort Array by Increasing Frequency.java

---
 Easy/Sort Array by Increasing Frequency.java | 31 +++++++++++---------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/Easy/Sort Array by Increasing Frequency.java b/Easy/Sort Array by Increasing Frequency.java
index 70512785..0fa7b374 100644
--- a/Easy/Sort Array by Increasing Frequency.java	
+++ b/Easy/Sort Array by Increasing Frequency.java	
@@ -1,21 +1,24 @@
 class Solution {
   public int[] frequencySort(int[] nums) {
-    Map<Integer, Long> counter = Arrays.stream(nums).boxed()
-        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())
-    );
-    PriorityQueue<Integer> frequencyMinHeap = new PriorityQueue<>((o1, o2) -> {
-      int c = (int) (counter.get(o1) - counter.get(o2));
-      return c != 0 ? c : o2 - o1;
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> {
+      int c = map.get(o1).compareTo(map.get(o2));
+      if (c != 0) {
+        return c;
+      }
+      return o2.compareTo(o1);
     });
-    frequencyMinHeap.addAll(counter.keySet());
-    int[] sortedByFrequency = new int[nums.length];
-    for (int idx = 0; idx < sortedByFrequency.length;) {
-      int value = frequencyMinHeap.poll();
-      long count = counter.get(value);
-      while (count-- > 0) {
-        sortedByFrequency[idx++] = value;
+    pq.addAll(map.keySet());
+    int idx = 0;
+    while (!pq.isEmpty()) {
+      int removed = pq.remove();
+      for (int i = 0; i < map.get(removed); i++) {
+        nums[idx++] = removed;
       }
     }
-    return sortedByFrequency;
+    return nums;
   }
 }

From a2667fe843613ac66d401f0cd80222d08c81a85c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 9 Sep 2022 12:06:53 -0700
Subject: [PATCH 1317/2175] Update and rename Easy/Sum of Even Numbers After
 Queries.java to Medium/Sum of Even Numbers After Queries.java

---
 Easy/Sum of Even Numbers After Queries.java   | 21 -------------------
 Medium/Sum of Even Numbers After Queries.java | 21 +++++++++++++++++++
 2 files changed, 21 insertions(+), 21 deletions(-)
 delete mode 100644 Easy/Sum of Even Numbers After Queries.java
 create mode 100644 Medium/Sum of Even Numbers After Queries.java

diff --git a/Easy/Sum of Even Numbers After Queries.java b/Easy/Sum of Even Numbers After Queries.java
deleted file mode 100644
index 8b7d1d27..00000000
--- a/Easy/Sum of Even Numbers After Queries.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-  public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
-    int sum = 0;
-    for (int num : A) {
-      sum += num % 2 == 0 ? num : 0;
-    }
-    int[] ans = new int[queries.length];
-    for (int i = 0; i < queries.length; i++) {
-      int newVal = A[queries[i][1]] + queries[i][0];
-      if (A[queries[i][1]] % 2 == 0) {
-        sum -= A[queries[i][1]];
-      }
-      A[queries[i][1]] = newVal;
-      if (A[queries[i][1]] % 2 == 0) {
-        sum += newVal;
-      }
-      ans[i] = sum;
-    }
-    return ans;
-  }
-}
diff --git a/Medium/Sum of Even Numbers After Queries.java b/Medium/Sum of Even Numbers After Queries.java
new file mode 100644
index 00000000..f8a3b043
--- /dev/null
+++ b/Medium/Sum of Even Numbers After Queries.java	
@@ -0,0 +1,21 @@
+class Solution {
+  public int[] sumEvenAfterQueries(int[] nums, int[][] queries) {
+    int evenSum = 0;
+    for (int num : nums) {
+      evenSum += num % 2 == 0 ? num : 0;
+    }
+    int[] result = new int[nums.length];
+    for (int i = 0; i < queries.length; i++) {
+      int idx = queries[i][1];
+      if (nums[idx] % 2 == 0) {
+        evenSum -= nums[idx];
+      }
+      nums[idx] += queries[i][0];
+      if (nums[idx] % 2 == 0) {
+        evenSum += nums[idx];
+      }
+      result[i] = evenSum;
+    }
+    return result;
+  }
+}

From 5b0b5fb9e09242222733f4bfda4591f2cac047ad Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 10 Sep 2022 07:48:02 -0700
Subject: [PATCH 1318/2175] Create Best Time to Buy and Sell Stock IV.java

---
 Hard/Best Time to Buy and Sell Stock IV.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Hard/Best Time to Buy and Sell Stock IV.java

diff --git a/Hard/Best Time to Buy and Sell Stock IV.java b/Hard/Best Time to Buy and Sell Stock IV.java
new file mode 100644
index 00000000..8aecbd84
--- /dev/null
+++ b/Hard/Best Time to Buy and Sell Stock IV.java	
@@ -0,0 +1,18 @@
+class Solution {
+  public int maxProfit(int k, int[] prices) {
+    if (k == 0) {
+      return 0;
+    }
+    int[][] dp = new int[k + 1][2];
+    for (int i = 0; i <= k; i++) {
+      dp[i][0] = 1000;
+    }
+    for (int i = 0; i < prices.length; i++) {
+      for (int j = 1; j <= k; j++) {
+        dp[j][0] = Math.min(dp[j][0], prices[i] - dp[j - 1][1]);
+        dp[j][1] = Math.max(dp[j][1], prices[i] - dp[j][0]);
+      }
+    }
+    return dp[k][1];
+  }
+}

From 2b894cb201d461c81a259a2e0ab3c74eca9421bf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Sep 2022 11:06:51 -0700
Subject: [PATCH 1319/2175] Create Maximum Performance of a Team.java

---
 Hard/Maximum Performance of a Team.java | 26 +++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Hard/Maximum Performance of a Team.java

diff --git a/Hard/Maximum Performance of a Team.java b/Hard/Maximum Performance of a Team.java
new file mode 100644
index 00000000..11a444da
--- /dev/null
+++ b/Hard/Maximum Performance of a Team.java	
@@ -0,0 +1,26 @@
+class Solution {
+  
+  private final static int MOD = (int) Math.pow(10, 9) + 7;
+  
+  public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
+    List<int[]> pairs = new ArrayList<>();
+    for (int i = 0; i < n; ++i) {
+      pairs.add(new int[]{efficiency[i], speed[i]});
+    }
+    Collections.sort(pairs, (o1, o2) -> o2[0] - o1[0]);
+    PriorityQueue<Integer> speedMinHeap = new PriorityQueue<>();
+    long speedSum = 0;
+    long performance = 0;
+    for (int[] pair : pairs) {
+      Integer currEfficiency = pair[0];
+      Integer currSpeed = pair[1];
+      if (speedMinHeap.size() > k - 1) {
+        speedSum -= speedMinHeap.remove();
+      }
+      speedMinHeap.add(currSpeed);
+      speedSum += currSpeed;
+      performance = Math.max(performance, speedSum * currEfficiency);
+    }
+    return (int) (performance % MOD);
+  }
+}

From 452ceafa9a1023886613d32b1b61466f9658a068 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Sep 2022 11:55:41 -0700
Subject: [PATCH 1320/2175] Create Most Frequent Even Element.java

---
 Easy/Most Frequent Even Element.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Most Frequent Even Element.java

diff --git a/Easy/Most Frequent Even Element.java b/Easy/Most Frequent Even Element.java
new file mode 100644
index 00000000..75879d03
--- /dev/null
+++ b/Easy/Most Frequent Even Element.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int mostFrequentEven(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : nums) {
+      if (num % 2 == 0) {
+        map.put(num, map.getOrDefault(num, 0) + 1);
+      }
+    }
+    int maxValue = 0;
+    int maxKey = -1;
+    for (Integer key : map.keySet()) {
+      if (map.get(key) >= maxValue) {
+        if (map.get(key) > maxValue) {
+          maxKey = key;
+        } else {
+          maxKey = Math.min(maxKey, key);
+        }
+        maxValue = map.get(key);
+      }
+    }
+    return maxKey;
+  }
+}

From ae3948e25c4c87e6c0b93101efbebc7e7087346f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Sep 2022 11:59:10 -0700
Subject: [PATCH 1321/2175] Create Optimal Partition of String.java

---
 Medium/Optimal Partition of String.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Optimal Partition of String.java

diff --git a/Medium/Optimal Partition of String.java b/Medium/Optimal Partition of String.java
new file mode 100644
index 00000000..2c42afa6
--- /dev/null
+++ b/Medium/Optimal Partition of String.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int partitionString(String s) {
+    int idx = 0;
+    int count = 0;
+    while (idx < s.length()) {
+      Set<Character> set = new HashSet<>();
+      while (idx < s.length() && set.add(s.charAt(idx))) {
+        idx++;
+      }
+      count++;
+    }
+    return count;
+  }
+}

From 4a2f1d4376a7f6477d65cdaae887622c223a3cb1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Sep 2022 14:01:03 -0700
Subject: [PATCH 1322/2175] Update Remove Nth Node From End of List.java

---
 Medium/Remove Nth Node From End of List.java | 23 ++++++++------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Medium/Remove Nth Node From End of List.java b/Medium/Remove Nth Node From End of List.java
index 44b990bd..f6f741f8 100644
--- a/Medium/Remove Nth Node From End of List.java	
+++ b/Medium/Remove Nth Node From End of List.java	
@@ -10,24 +10,19 @@
  */
 class Solution {
   public ListNode removeNthFromEnd(ListNode head, int n) {
-    if (head == null || n == 0) {
-      return head;
+    ListNode curr = head;
+    while (n-- > 0) {
+      curr = curr.next;
     }
-    ListNode slow = head;
-    int count = 0;
-    while (count < n) {
-      slow = slow.next;
-      count++;
-    }
-    if (slow == null) {
+    if (curr == null) {
       return head.next;
     }
-    ListNode fast = head;
-    while (slow.next != null) {
-      slow = slow.next;
-      fast = fast.next;
+    ListNode slowNode = head;
+    while (curr.next != null) {
+      slowNode = slowNode.next;
+      curr = curr.next;
     }
-    fast.next = fast.next.next;
+    slowNode.next = slowNode.next.next;
     return head;
   }
 }

From 5038df57b37ae6f4ba9f3c9b8c637c322f8162de Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Sep 2022 19:48:02 -0700
Subject: [PATCH 1323/2175] Create Bag of Tokens.java

---
 Medium/Bag of Tokens.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Bag of Tokens.java

diff --git a/Medium/Bag of Tokens.java b/Medium/Bag of Tokens.java
new file mode 100644
index 00000000..d86085c3
--- /dev/null
+++ b/Medium/Bag of Tokens.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public int bagOfTokensScore(int[] tokens, int power) {
+    int score = 0;
+    Arrays.sort(tokens);
+    int leftIdx = 0;
+    int rightIdx = tokens.length - 1;
+    int currScore = 0;
+    while (leftIdx <= rightIdx) {
+      if (power >= tokens[leftIdx]) {
+        currScore++;
+        power -= tokens[leftIdx++];
+      } else {
+        if (currScore == 0) {
+          break;
+        }
+        currScore--;
+        power += tokens[rightIdx--];
+      }
+      score = Math.max(score, currScore);
+    }
+    return score;
+  }
+}

From 3e693f3abded64a38adb6f65c29da97fa621bf44 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 12 Sep 2022 07:30:32 -0700
Subject: [PATCH 1324/2175] Update ZigZag Conversion.java

---
 Medium/ZigZag Conversion.java | 45 +++++++++++++++++------------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/Medium/ZigZag Conversion.java b/Medium/ZigZag Conversion.java
index d3c2cc5c..62539da4 100644
--- a/Medium/ZigZag Conversion.java	
+++ b/Medium/ZigZag Conversion.java	
@@ -1,26 +1,25 @@
 class Solution {
-    public String convert(String s, int numRows) {
-        List<StringBuilder> list = new ArrayList<>();
-        for (int i = 0; i < numRows; i++) {
-            list.add(new StringBuilder());
-        }
-        
-        int idx = 0;
-        while (idx < s.length()) {
-            for (int i = 0; i < numRows && idx < s.length(); i++) {
-                list.get(i).append(s.charAt(idx++));
-            }
-            
-            for (int i = numRows - 2; i > 0 && idx < s.length(); i--) {
-                list.get(i).append(s.charAt(idx++));
-            }
-        }
-        
-        StringBuilder ans = new StringBuilder();
-        for (StringBuilder sb : list) {
-            ans.append(sb.toString());
-        }
-        
-        return ans.toString();
+  public String convert(String s, int numRows) {
+    if (numRows == 1) {
+      return s;
     }
+    List<StringBuilder> list = new ArrayList<>();
+    for (int i = 0; i < numRows; i++) {
+      list.add(new StringBuilder());
+    }
+    int idx = 0;
+    boolean downDirection = false;
+    for (char c : s.toCharArray()) {
+      list.get(idx).append(c);
+      if (idx == 0 || idx == numRows - 1) {
+        downDirection = !downDirection;
+      }
+      idx += downDirection ? 1 : -1;
+    }
+    StringBuilder result = new StringBuilder();
+    for (StringBuilder sb : list) {
+      result.append(sb.toString());
+    }
+    return result.toString();
+  }
 }

From 457dda28824acbc92edd197eed8231f82754ecd0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 12 Sep 2022 07:50:17 -0700
Subject: [PATCH 1325/2175] Update and rename String to Integer(atoi).java to
 String to Integer (atoi).java

---
 Medium/String to Integer (atoi).java | 30 ++++++++++++++++++++++++++++
 Medium/String to Integer(atoi).java  | 23 ---------------------
 2 files changed, 30 insertions(+), 23 deletions(-)
 create mode 100644 Medium/String to Integer (atoi).java
 delete mode 100644 Medium/String to Integer(atoi).java

diff --git a/Medium/String to Integer (atoi).java b/Medium/String to Integer (atoi).java
new file mode 100644
index 00000000..e91cbec0
--- /dev/null
+++ b/Medium/String to Integer (atoi).java	
@@ -0,0 +1,30 @@
+class Solution {
+  public int myAtoi(String s) {
+    int idx = 0;
+    int n = s.length();
+    while (idx < n && s.charAt(idx) == ' ') {
+      idx++;
+    }
+    int sign = 1;
+    if (idx < n && (s.charAt(idx) == '-' || s.charAt(idx) == '+')) {
+      sign = s.charAt(idx) == '-' ? -1 : 1;
+      idx++;
+    }
+    if (idx == n || !Character.isDigit(s.charAt(idx))) {
+      return 0;
+    }
+    while (idx < n && s.charAt(idx) == '0') {
+      idx++;
+    }
+    int number = 0;
+    while (idx < n && Character.isDigit(s.charAt(idx))) {
+      int digit = Character.getNumericValue(s.charAt(idx));
+      if ((number > Integer.MAX_VALUE / 10) || (number == Integer.MAX_VALUE / 10 && digit > Integer.MAX_VALUE % 10)) {
+        return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
+      }
+      number = number * 10 + digit;
+      idx++;
+    }
+    return number * sign;
+  }
+}
diff --git a/Medium/String to Integer(atoi).java b/Medium/String to Integer(atoi).java
deleted file mode 100644
index 54fc622d..00000000
--- a/Medium/String to Integer(atoi).java	
+++ /dev/null
@@ -1,23 +0,0 @@
-class Solution {
-  public int myAtoi(String s) {
-    int idx = 0;
-    int n = s.length();
-    while (idx < n && s.charAt(idx) == ' ') {
-      idx++;
-    }
-    int sign = 1;
-    if (idx < n && (s.charAt(idx) == '+' || s.charAt(idx) == '-')) {
-      sign = s.charAt(idx++) == '-' ? -1 : 1;
-    }
-    long num = 0;
-    while (idx < n && Character.isDigit(s.charAt(idx))) {
-      num = num * 10 + Character.getNumericValue(s.charAt(idx++));
-      if (sign == 1 && num > Integer.MAX_VALUE) {
-        return Integer.MAX_VALUE;
-      } else if (sign == -1 && num * sign < Integer.MIN_VALUE) {
-        return Integer.MIN_VALUE;
-      }
-    }
-    return (int) (num * sign);
-  }
-}

From c6f4a2a1ede125f9db16e34cf2de614cca1765c9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 12 Sep 2022 14:50:29 -0700
Subject: [PATCH 1326/2175] Update 3Sum Closest.java

---
 Medium/3Sum Closest.java | 41 ++++++++++++++++++----------------------
 1 file changed, 18 insertions(+), 23 deletions(-)

diff --git a/Medium/3Sum Closest.java b/Medium/3Sum Closest.java
index ed469e0e..7520f9ea 100644
--- a/Medium/3Sum Closest.java	
+++ b/Medium/3Sum Closest.java	
@@ -1,27 +1,22 @@
 class Solution {
-    public int threeSumClosest(int[] nums, int target) {
-        int sum = Integer.MAX_VALUE;
-        Arrays.sort(nums);
-        
-        for (int i=0; i<nums.length; i++) {
-            int j = i + 1;
-            int k = nums.length - 1;
-            
-            while (j < k) {
-                int tempSum = nums[i] + nums[j] + nums[k];
-                if (sum == Integer.MAX_VALUE || Math.abs(sum - target) > Math.abs(target - tempSum)) {
-                    sum = tempSum;
-                }
-                
-                if (tempSum > target) {
-                    k--;
-                }
-                else {
-                    j++;
-                }    
-            }
+  public int threeSumClosest(int[] nums, int target) {
+    Arrays.sort(nums);
+    int closestDiff = Integer.MAX_VALUE;
+    for (int i = 0; i < nums.length; i++) {
+      int start = i + 1;
+      int end = nums.length - 1;
+      while (start < end) {
+        int currSum = nums[i] + nums[start] + nums[end];
+        if (Math.abs(target - currSum) < Math.abs(closestDiff)) {
+          closestDiff = target - currSum;
         }
-        
-        return sum;
+        if (currSum < target) {
+          start++;
+        } else {
+          end--;
+        }
+      }
     }
+    return target - closestDiff;
+  }
 }

From d1c76836d08f9ba35581e4167b1e6c0e7660efa1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 12 Sep 2022 15:33:25 -0700
Subject: [PATCH 1327/2175] Update Combination Sum II.java

---
 Medium/Combination Sum II.java | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/Medium/Combination Sum II.java b/Medium/Combination Sum II.java
index 5b525f70..954373f5 100644
--- a/Medium/Combination Sum II.java	
+++ b/Medium/Combination Sum II.java	
@@ -1,26 +1,25 @@
 class Solution {
   public List<List<Integer>> combinationSum2(int[] candidates, int target) {
-    List<List<Integer>> list = new ArrayList<>();
+    List<List<Integer>> result = new ArrayList<>();
     Arrays.sort(candidates);
-    helper(candidates, 0, target, new ArrayList<>(), list);
-    return list;
+    helper(candidates, target, result, new ArrayList<>(), 0);
+    return result;
   }
   
-  private void helper(int[] candidates, int idx, int target, List<Integer> temp, List<List<Integer>> list) {
-    if (target == 0) {
-      list.add(new ArrayList<>(temp));
-      return;
-    }
-    if (target < 0) {
+  private void helper(int[] candidates, int target, List<List<Integer>> result, List<Integer> currCombination, int idx) {
+    if (target <= 0) {
+      if (target == 0) {
+        result.add(new ArrayList<>(currCombination));
+      }
       return;
     }
     for (int i = idx; i < candidates.length; i++) {
-      if (i > idx && candidates[i] == candidates[i - 1]) { 
+      if (i > idx && candidates[i] == candidates[i - 1]) {
         continue;
       }
-      temp.add(candidates[i]);
-      helper(candidates, i + 1, target - candidates[i], temp, list);
-      temp.remove(temp.size() - 1);
+      currCombination.add(candidates[i]);
+      helper(candidates, target - candidates[i], result, currCombination, i + 1);
+      currCombination.remove(currCombination.size() - 1);
     }
   }
 }

From b7aa3d64d13bf9be8fbb9944a7afcf091521406a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 12 Sep 2022 20:41:18 -0700
Subject: [PATCH 1328/2175] Create UTF-8 Validation.java

---
 Medium/UTF-8 Validation.java | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/UTF-8 Validation.java

diff --git a/Medium/UTF-8 Validation.java b/Medium/UTF-8 Validation.java
new file mode 100644
index 00000000..bf7140f0
--- /dev/null
+++ b/Medium/UTF-8 Validation.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public boolean validUtf8(int[] data) {
+    int numberOfBytes = 0;
+    for (int i = 0; i < data.length; i++) {
+      String binaryRep = Integer.toBinaryString(data[i]);
+      binaryRep = binaryRep.length() >= 8 ? 
+        binaryRep.substring(binaryRep.length() - 8) : 
+      "00000000".substring(binaryRep.length() % 8) + binaryRep;
+      if (numberOfBytes == 0) {
+        for (int j = 0; j < binaryRep.length(); j++) {
+          if (binaryRep.charAt(j) == '0') {
+            break;
+          }
+          numberOfBytes++;
+        }
+        if (numberOfBytes == 0) {
+          continue;
+        }
+        if (numberOfBytes > 4 || numberOfBytes == 1) {
+          return false;
+        } 
+      } else {
+        if (!(binaryRep.charAt(0) == '1' && binaryRep.charAt(1) == '0')) {
+          return false;
+        }
+      }
+      numberOfBytes--;
+    }
+    return numberOfBytes == 0;
+  }
+}

From 722af37143ca4e3b7edefea0ee8b020631b48262 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 13 Sep 2022 16:00:56 -0700
Subject: [PATCH 1329/2175] Update Next Greater Element II.java

---
 Medium/Next Greater Element II.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Medium/Next Greater Element II.java b/Medium/Next Greater Element II.java
index 367351ae..c392b087 100644
--- a/Medium/Next Greater Element II.java	
+++ b/Medium/Next Greater Element II.java	
@@ -1,23 +1,23 @@
 class Solution {
   public int[] nextGreaterElements(int[] nums) {
-    int[] ans = new int[nums.length];
+    int[] result = new int[nums.length];
     Stack<Integer> stack = new Stack<>();
     for (int i = nums.length - 1; i >= 0; i--) {
       while (!stack.isEmpty() && nums[stack.peek()] <= nums[i]) {
         stack.pop();
       }
-      ans[i] = stack.isEmpty() ? -1 : nums[stack.peek()];
+      result[i] = stack.isEmpty() ? -1 : nums[stack.peek()];
       stack.push(i);
     }
     for (int i = nums.length - 1; i >= 0; i--) {
-      if (ans[i] == -1) {
+      if (result[i] == -1) {
         while (!stack.isEmpty() && nums[stack.peek()] <= nums[i]) {
           stack.pop();
         }
-        ans[i] = stack.isEmpty() ? -1 : nums[stack.peek()];
+        result[i] = stack.isEmpty() ? -1 : nums[stack.peek()];
       }
       stack.push(i);
     }
-    return ans;
+    return result;
   }
 }

From a4413078aa84ba7037b75ee2c9fed98f4f5516ea Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 13 Sep 2022 16:57:10 -0700
Subject: [PATCH 1330/2175] Update Complex Number Multiplication.java

---
 Medium/Complex Number Multiplication.java | 64 +++++++++++++++++++++--
 1 file changed, 59 insertions(+), 5 deletions(-)

diff --git a/Medium/Complex Number Multiplication.java b/Medium/Complex Number Multiplication.java
index 0eb7dd43..f6d2500b 100644
--- a/Medium/Complex Number Multiplication.java	
+++ b/Medium/Complex Number Multiplication.java	
@@ -1,9 +1,63 @@
 class Solution {
   public String complexNumberMultiply(String num1, String num2) {
-    int realPartOne = Integer.parseInt(num1.split("\\+")[0]);
-    int imaginaryPartOne = Integer.parseInt(num1.split("\\+")[1].substring(0, num1.split("\\+")[1].length() - 1));
-    int realPartTwo = Integer.parseInt(num2.split("\\+")[0]);
-    int imaginaryPartTwo = Integer.parseInt(num2.split("\\+")[1].substring(0, num2.split("\\+")[1].length() - 1));
-    return (realPartOne * realPartTwo - imaginaryPartOne * imaginaryPartTwo) + "+" + (realPartOne * imaginaryPartTwo + realPartTwo * imaginaryPartOne) + "i";
+    ComplexNumber result = ComplexNumber.buildComplexNumber(num1).multiply(ComplexNumber.buildComplexNumber(num2));
+    return result.toString();
+  }
+  
+  
+  private static class ComplexNumber {
+    
+    private final int real;
+    private final int imaginary;
+    
+    private ComplexNumber(int real, int imaginary) {
+      this.real = real;
+      this.imaginary = imaginary;
+    }
+    
+    public static ComplexNumber buildComplexNumber(String s) {
+      int[] idx = {0};
+      int realPart = parseRealPart(s, idx);
+      int imaginaryPart = parseImaginaryPart(s, idx);
+      return new ComplexNumber(realPart, imaginaryPart);
+    }
+    
+    public ComplexNumber multiply(ComplexNumber anotherNumber) {
+      int realPart = this.real * anotherNumber.real + (this.imaginary * anotherNumber.imaginary * -1);
+      int imaginaryPart = this.real * anotherNumber.imaginary + this.imaginary * anotherNumber.real;
+      return new ComplexNumber(realPart, imaginaryPart);
+    }
+    
+    public String toString() {
+      return this.real + "+" + this.imaginary + "i";
+    }
+    
+    private static int parseRealPart(String s, int[] idx) {
+      int realSign = 1;
+      if (s.charAt(idx[0]) == '+' || s.charAt(idx[0]) == '-') {
+        realSign = s.charAt(idx[0]) == '-' ? -1 : 1;
+        idx[0]++;
+      }
+      int realNum = 0;
+      while (idx[0] < s.length() && Character.isDigit(s.charAt(idx[0]))) {
+        realNum = realNum * 10 + Character.getNumericValue(s.charAt(idx[0]++));
+      }
+      realNum *= realSign;
+      idx[0]++;
+      return realNum;
+    }
+    
+    private static int parseImaginaryPart(String s, int[] idx) {
+      int imaginarySign = 1;
+      if (idx[0] < s.length() && (s.charAt(idx[0]) == '+' || s.charAt(idx[0]) == '-')) {
+        imaginarySign = s.charAt(idx[0]) == '-' ? -1 : 1;
+        idx[0]++;
+      } 
+      int imaginaryNum = 0;
+      while (idx[0] < s.length() && s.charAt(idx[0]) != 'i') {
+        imaginaryNum = imaginaryNum * 10 + Character.getNumericValue(s.charAt(idx[0]++));
+      }
+      return imaginarySign * imaginaryNum;
+    }
   }
 }

From 1953be190ff2da866a9f2ed4e5877e75978a99c3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 14 Sep 2022 07:36:53 -0700
Subject: [PATCH 1331/2175] Update Pseudo-Palindromic Paths in a Binary
 Tree.java

---
 ...do-Palindromic Paths in a Binary Tree.java | 57 ++++++++++---------
 1 file changed, 31 insertions(+), 26 deletions(-)

diff --git a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java
index f6b9498f..04cbe822 100644
--- a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java	
+++ b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java	
@@ -15,37 +15,42 @@
  */
 class Solution {
   public int pseudoPalindromicPaths (TreeNode root) {
-    int[] map = new int[10];
-    int[] count = {0};
-    pseudoPalindromicPathsUtil(root, map, count);
-    return count[0];
-  }
-  
-  private boolean isPalindrome(int[] map) {
-    boolean oddFound = false;
-    for(int i = 1; i <= 9; i++) {
-      if (map[i] % 2 != 0) {
-        if (oddFound) {
-          return false;
+    Queue<NodePathPair> queue = new LinkedList<>();
+    NodePathPair nodePathPair = new NodePathPair(root, 0);
+    queue.add(nodePathPair);
+    int count = 0;
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        NodePathPair removed = queue.remove();
+        TreeNode node = removed.node;
+        int path = removed.path;
+        // XOR operation ensures that the bit corresponding to the number only appears in the
+        // path if it has occurred odd number of times. 
+        // 1 << node.val decides the bit of the value
+        path = path ^ (1 << node.val);
+        if (node.left == null && node.right == null) {
+          // Subtracting 1 means setting rightmost 1 bit to 0 and setting all lower bits to 1
+          count += (path & (path - 1)) == 0 ? 1 : 0;
+        } 
+        if (node.left != null) {
+          queue.add(new NodePathPair(node.left, path));
+        }
+        if (node.right != null) {
+          queue.add(new NodePathPair(node.right, path));
         }
-        oddFound = true;
       }
     }
-    return true;
+    return count;
   }
   
-  private void pseudoPalindromicPathsUtil(TreeNode root, int[] map, int[] count) {
-    if (root == null) {
-      return;
-    }
-    map[root.val] = map[root.val] + 1;
-    if (root.left == null && root.right == null) {
-      if (isPalindrome(map)) {
-        count[0]++;
-      }
+  private static class NodePathPair {
+    TreeNode node;
+    Integer path;
+    
+    public NodePathPair(TreeNode node, int path) {
+      this.node = node;
+      this.path = path;
     }
-    pseudoPalindromicPathsUtil(root.left, map, count);
-    pseudoPalindromicPathsUtil(root.right, map, count);
-    map[root.val] = map[root.val] - 1;
   }
 }

From 22b12be01a0659a3c439ec883e0357241a262df7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 14 Sep 2022 10:15:55 -0700
Subject: [PATCH 1332/2175] Update Find Common Characters.java

---
 Easy/Find Common Characters.java | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/Easy/Find Common Characters.java b/Easy/Find Common Characters.java
index e813b42e..e9fa97e4 100644
--- a/Easy/Find Common Characters.java	
+++ b/Easy/Find Common Characters.java	
@@ -1,21 +1,23 @@
 class Solution {
-  public List<String> commonChars(String[] A) {
-    int[][] counter = new int[A.length][26];
-    for (int i = 0; i < A.length; i++) {
-      for (char c : A[i].toCharArray()) {
-        counter[i][c - 'a']++;
+  public List<String> commonChars(String[] words) {
+    int[] commonFrequency = new int[26];
+    Arrays.fill(commonFrequency, Integer.MAX_VALUE);
+    for (String word : words) {
+      int[] wordFreq = new int[26];
+      for (char c : word.toCharArray()) {
+        wordFreq[c - 'a']++;
+      }
+      for (int i = 0; i < 26; i++) {
+        commonFrequency[i] = Math.min(commonFrequency[i], wordFreq[i]);
       }
     }
-    List<String> list = new ArrayList<>();
+    List<String> result = new ArrayList<>();
     for (int i = 0; i < 26; i++) {
-      int minCount = Integer.MAX_VALUE;
-      for (int j = 0; j < counter.length; j++) {
-        minCount = Math.min(minCount, counter[j][i]);
-      }
-      while (minCount-- > 0) {
-        list.add(String.valueOf((char) (97 + i)));
+      int count = commonFrequency[i];
+      while (count-- > 0) {
+        result.add(String.valueOf((char) (97 + i)));
       }
     }
-    return list;
+    return result;
   }
 }

From 9d1ac1c000f22d8e829c74d18e8577b670021a81 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 14 Sep 2022 14:07:17 -0700
Subject: [PATCH 1333/2175] Update N-Repeated Element in Size 2N Array.java

---
 Easy/N-Repeated Element in Size 2N Array.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Easy/N-Repeated Element in Size 2N Array.java b/Easy/N-Repeated Element in Size 2N Array.java
index 07a2ddcc..f5ede891 100644
--- a/Easy/N-Repeated Element in Size 2N Array.java	
+++ b/Easy/N-Repeated Element in Size 2N Array.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public int repeatedNTimes(int[] A) {
-    int[] arr = new int[10001];
-    for (int num : A) {
-      if (arr[num] == 1) {
-        return num;
+  public int repeatedNTimes(int[] nums) {
+    for (int i = 1; i <= 3; i++) {
+      for (int j = 0; j < nums.length - i; j++) {
+        if (nums[j] == nums[j + i]) {
+          return nums[j];
+        }
       }
-      arr[num]++;
     }
     return -1;
   }

From e80d7a038a078d53fea9a0467095ae01db4a0e15 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 14 Sep 2022 14:08:44 -0700
Subject: [PATCH 1334/2175] Update and rename Easy/Subdomain Visit Count.java
 to Medium/Subdomain Visit Count.java

---
 Easy/Subdomain Visit Count.java   | 21 ---------------------
 Medium/Subdomain Visit Count.java | 22 ++++++++++++++++++++++
 2 files changed, 22 insertions(+), 21 deletions(-)
 delete mode 100644 Easy/Subdomain Visit Count.java
 create mode 100644 Medium/Subdomain Visit Count.java

diff --git a/Easy/Subdomain Visit Count.java b/Easy/Subdomain Visit Count.java
deleted file mode 100644
index 5c99417d..00000000
--- a/Easy/Subdomain Visit Count.java	
+++ /dev/null
@@ -1,21 +0,0 @@
-class Solution {
-  public List<String> subdomainVisits(String[] cpdomains) {
-    Map<String, Integer> map = new HashMap<>();
-    for (String domain : cpdomains) {
-      String[] strs = domain.split("\\s+");
-      int count = Integer.parseInt(strs[0]);
-      String[] lowerDomains = strs[1].split("\\.");
-      StringBuilder sb = new StringBuilder();
-      for (int i = lowerDomains.length - 1; i >= 0; i--) {
-        sb.insert(0, lowerDomains[i]);
-        map.put(sb.toString(), map.getOrDefault(sb.toString(), 0) + count);
-        sb.insert(0, '.');
-      }
-    }
-    List<String> list = new ArrayList<>();
-    for (String key : map.keySet()) {
-      list.add(map.get(key) + " " + key);
-    }
-    return list;
-  }
-}
diff --git a/Medium/Subdomain Visit Count.java b/Medium/Subdomain Visit Count.java
new file mode 100644
index 00000000..f7900ef6
--- /dev/null
+++ b/Medium/Subdomain Visit Count.java	
@@ -0,0 +1,22 @@
+class Solution {
+  public List<String> subdomainVisits(String[] cpdomains) {
+    Map<String, Long> map = new HashMap<>();
+    for (String cpdomain : cpdomains) {
+      int spaceIdx = cpdomain.indexOf(' ');
+      int count = Integer.parseInt(cpdomain.substring(0, spaceIdx));
+      String[] subdomains = cpdomain.substring(spaceIdx + 1).split("\\.");
+      StringBuilder sb = new StringBuilder();
+      for (int i = subdomains.length - 1; i >= 0; i--) {
+        sb.insert(0, subdomains[i]);
+        String currDomain = sb.toString();
+        map.put(currDomain, map.getOrDefault(currDomain, 0L) + count);
+        sb.insert(0, ".");
+      }
+    }
+    List<String> result = new ArrayList<>();
+    for (String key : map.keySet()) {
+      result.add(map.get(key) + " " + key);
+    }
+    return result;
+  }
+}

From 396d202e43f1b53078b8bce1098bfe8134bb5f34 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 14 Sep 2022 19:59:50 -0700
Subject: [PATCH 1335/2175] Update Find Original Array From Doubled Array.java

---
 ...ind Original Array From Doubled Array.java | 30 +++++++++++--------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/Medium/Find Original Array From Doubled Array.java b/Medium/Find Original Array From Doubled Array.java
index 3c4c7dc6..55554c81 100644
--- a/Medium/Find Original Array From Doubled Array.java	
+++ b/Medium/Find Original Array From Doubled Array.java	
@@ -3,19 +3,25 @@ public int[] findOriginalArray(int[] changed) {
     if (changed.length % 2 != 0) {
       return new int[]{};
     }
-    int[] answer = new int[changed.length / 2];
-    int idx = 0;
-    Map<Integer, Long> map = Arrays.stream(changed).boxed()
-        .collect(Collectors.groupingBy(Function.identity(), TreeMap::new, Collectors.counting()));
-    for (Integer key : map.keySet()) {
-      if (map.get(key) > map.getOrDefault(key * 2, 0L)) {
-        return new int[0];
-      }
-      for (int i = 0; i < map.get(key); i++) {
-        answer[idx++] = key;
-        map.put(key * 2, map.get(key * 2) - 1);
+    Arrays.sort(changed);
+    Map<Integer, Integer> map = new HashMap<>();
+    for (int num : changed) {
+      map.put(num, map.getOrDefault(num, 0) + 1);
+    }
+    int[] result = new int[changed.length / 2];
+    int resultIdx = 0;
+    for (int num : changed) {
+      if (map.get(num) > 0) {
+        map.put(num, map.get(num) - 1);
+        int doubleValue = num * 2;
+        if (map.getOrDefault(doubleValue, 0) > 0) {
+          map.put(doubleValue, map.get(doubleValue) - 1);
+          result[resultIdx++] = num;
+        } else {
+          return new int[]{};
+        }
       }
     }
-    return answer;
+    return result;
   }
 }

From f112596d367a8c2ac545acf5073fa1e8a1c8d94e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 15 Sep 2022 07:31:35 -0700
Subject: [PATCH 1336/2175] Update Top K Frequent Words.java

---
 Medium/Top K Frequent Words.java | 36 +++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/Medium/Top K Frequent Words.java b/Medium/Top K Frequent Words.java
index 50a3911f..7f1c4f9f 100644
--- a/Medium/Top K Frequent Words.java	
+++ b/Medium/Top K Frequent Words.java	
@@ -1,23 +1,29 @@
 class Solution {
   public List<String> topKFrequent(String[] words, int k) {
-    Map<String, Integer> map = new HashMap<>();
+    Map<String, Integer> wordFrequency = new HashMap<>();
+    Map<Integer, Set<String>> frequencyToWord = new HashMap<>();
+    int maxFrequency = 0;
     for (String word : words) {
-      map.put(word, map.getOrDefault(word, 0) + 1);
+      if (!wordFrequency.containsKey(word)) {
+        wordFrequency.put(word, 1);
+        frequencyToWord.computeIfAbsent(1, j -> new HashSet<>()).add(word);
+      } else {
+        int oldFrequency = wordFrequency.get(word);
+        int newFrequency = oldFrequency + 1;
+        wordFrequency.put(word, newFrequency);
+        frequencyToWord.get(oldFrequency).remove(word);
+        frequencyToWord.computeIfAbsent(newFrequency, j -> new HashSet<>()).add(word);
+      }
+      maxFrequency = Math.max(maxFrequency, wordFrequency.get(word));
     }
-    PriorityQueue<String> pq = new PriorityQueue<>(new Comparator<String>(){
-      public int compare(String s1, String s2) {
-        int c = map.get(s2) - map.get(s1);
-        if (c != 0) {
-          return c;
-        }
-        return s1.compareTo(s2);
+    List<String> result = new ArrayList<>();
+    for (int i = maxFrequency; i > 0 && result.size() < k; i--) {
+      List<String> currFreqWords = new ArrayList<>(frequencyToWord.get(i));
+      Collections.sort(currFreqWords);
+      for (int j = 0; j < currFreqWords.size() && result.size() < k; j++) {
+        result.add(currFreqWords.get(j));
       }
-    });
-    pq.addAll(map.keySet());
-    List<String> ans = new ArrayList<>();
-    while (!pq.isEmpty() && k-- > 0) {
-      ans.add(pq.poll());
     }
-    return ans;
+    return result;
   }
 }

From dfc1f84c3a0f1f2a89356f79bd22b84200681643 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 15 Sep 2022 13:01:26 -0700
Subject: [PATCH 1337/2175] Create K Radius Subarray Averages.java

---
 Medium/K Radius Subarray Averages.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/K Radius Subarray Averages.java

diff --git a/Medium/K Radius Subarray Averages.java b/Medium/K Radius Subarray Averages.java
new file mode 100644
index 00000000..18cd8995
--- /dev/null
+++ b/Medium/K Radius Subarray Averages.java	
@@ -0,0 +1,24 @@
+class Solution {
+  public int[] getAverages(int[] nums, int k) {
+    int[] result = new int[nums.length];
+    Arrays.fill(result, -1);
+    int subarrayLength = 2 * k + 1;
+    if (subarrayLength > nums.length) {
+      return result;
+    }
+    long sum = 0;
+    for (int i = 0; i < subarrayLength; i++) {
+      sum += nums[i];
+    }
+    int startIdx = 0;
+    int endIdx = subarrayLength;
+    for (int i = k; i < nums.length - k; i++) {
+      result[i] = (int) (sum / subarrayLength);
+      sum -= nums[startIdx++];
+      if (endIdx < nums.length) {
+        sum += nums[endIdx++];
+      }
+    }
+    return result;
+  }
+}

From 003179ae1fa467df539e131cd0ce245fa35b4178 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 15 Sep 2022 16:20:33 -0700
Subject: [PATCH 1338/2175] Update Intersection of Two Arrays.java

---
 Easy/Intersection of Two Arrays.java | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/Easy/Intersection of Two Arrays.java b/Easy/Intersection of Two Arrays.java
index b17c8dea..d05f4468 100644
--- a/Easy/Intersection of Two Arrays.java	
+++ b/Easy/Intersection of Two Arrays.java	
@@ -1,20 +1,25 @@
 class Solution {
   public int[] intersection(int[] nums1, int[] nums2) {
-    Set<Integer> set = new HashSet<>();
+    boolean[][] found = new boolean[1001][2];
     for (int num : nums1) {
-      set.add(num);
+      found[num][0] = true;
     }
-    Set<Integer> match = new HashSet<>();
+    int count = 0;
     for (int num : nums2) {
-      if (set.contains(num)) {
-        match.add(num);
+      if (!found[num][1]) {
+        if (found[num][0]) {
+          count++;
+        }
       }
+      found[num][1] = true;
     }
-    int[] ans = new int[match.size()];
-    Iterator<Integer> iter = match.iterator();
-    for (int i = 0; i < ans.length; i++) {
-      ans[i] = iter.next();
+    int[] result = new int[count];
+    int idx = 0;
+    for (int i = 1; i <= 1000; i++) {
+      if (found[i][0] && found[i][1]) {
+        result[idx++] = i;
+      }
     }
-    return ans;
+    return result;
   }
 }

From e84f22ba27be858d3241646af5f7f4e9e50d4130 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 15 Sep 2022 16:23:26 -0700
Subject: [PATCH 1339/2175] Update Lowest Common Ancestor of Deepest
 Leaves.java

---
 ...est Common Ancestor of Deepest Leaves.java | 64 ++++++++++---------
 1 file changed, 33 insertions(+), 31 deletions(-)

diff --git a/Medium/Lowest Common Ancestor of Deepest Leaves.java b/Medium/Lowest Common Ancestor of Deepest Leaves.java
index 4517a201..d1fdfc59 100644
--- a/Medium/Lowest Common Ancestor of Deepest Leaves.java	
+++ b/Medium/Lowest Common Ancestor of Deepest Leaves.java	
@@ -4,40 +4,42 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
-class Solution {    
-    public TreeNode lcaDeepestLeaves(TreeNode root) {
-        return helper(root).lowesetCommonAncestor;
+class Solution {
+  public TreeNode lcaDeepestLeaves(TreeNode root) {
+    return dfs(root).node;
+  }
+  
+  private NodeResult dfs(TreeNode root) {
+    if (root == null) {
+      return new NodeResult(null, 0);
     }
-    
-    private UpdatedTreeNode helper(TreeNode root) {       
-        if (root == null) {
-            return new UpdatedTreeNode(0, null);
-        }
-        
-        UpdatedTreeNode leftUpdated = helper(root.left);
-        UpdatedTreeNode rightUpdated = helper(root.right);
-        
-        if (leftUpdated.depth == rightUpdated.depth) {
-            return new UpdatedTreeNode(leftUpdated.depth + 1, root);
-        }
-        else if (leftUpdated.depth > rightUpdated.depth) {
-            return new UpdatedTreeNode(leftUpdated.depth + 1, leftUpdated.lowesetCommonAncestor);
-        }
-        else {
-            return new UpdatedTreeNode(rightUpdated.depth + 1, rightUpdated.lowesetCommonAncestor);
-        }
+    NodeResult leftResult = dfs(root.left);
+    NodeResult rightResult = dfs(root.right);
+    if (leftResult.distance > rightResult.distance) {
+      return new NodeResult(leftResult.node, leftResult.distance + 1);
     }
-}
-
-class UpdatedTreeNode {
-    public int depth;
-    public TreeNode lowesetCommonAncestor;
-
-    public UpdatedTreeNode(int depth, TreeNode node) {
-        this.depth = depth;
-        this.lowesetCommonAncestor = node;
+    if (leftResult.distance < rightResult.distance) {
+      return new NodeResult(rightResult.node, rightResult.distance + 1);
+    }
+    return new NodeResult(root, rightResult.distance + 1);
+  }
+  
+  private static class NodeResult {
+    TreeNode node;
+    int distance;
+    
+    public NodeResult(TreeNode node, int distance) {
+      this.node = node;
+      this.distance = distance;
     }
+  }
 }

From 1db3190d568e0f894e666e6b14a557c2fc0939d9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 15 Sep 2022 16:26:08 -0700
Subject: [PATCH 1340/2175] Update Smallest Subtree with all the Deepest
 Nodes.java

---
 ...st Subtree with all the Deepest Nodes.java | 47 ++++++++-----------
 1 file changed, 19 insertions(+), 28 deletions(-)

diff --git a/Medium/Smallest Subtree with all the Deepest Nodes.java b/Medium/Smallest Subtree with all the Deepest Nodes.java
index 3999f22e..5ad5f59d 100644
--- a/Medium/Smallest Subtree with all the Deepest Nodes.java	
+++ b/Medium/Smallest Subtree with all the Deepest Nodes.java	
@@ -14,41 +14,32 @@
  * }
  */
 class Solution {
-  Map<TreeNode, Integer> map;
-  int maxDepth;
   public TreeNode subtreeWithAllDeepest(TreeNode root) {
-    map = new HashMap<>();
-    maxDepth = -1;
-    map.put(null, -1);
-    dfs(root, null);
-    return helper(root);
+    return dfs(root).node;
   }
   
-  private void dfs(TreeNode root, TreeNode parent) {
+  private NodeResult dfs(TreeNode root) {
     if (root == null) {
-      return;
+      return new NodeResult(null, 0);
     }
-    map.put(root, map.get(parent) + 1);
-    maxDepth = Math.max(maxDepth, map.get(root));
-    dfs(root.left, root);
-    dfs(root.right, root);
-  }
-  
-  private TreeNode helper(TreeNode root) {
-    if (root == null || map.get(root) == maxDepth) {
-      return root;
-    }
-    TreeNode left = helper(root.left);
-    TreeNode right = helper(root.right);
-    if (left != null && right != null) {
-      return root;
+    NodeResult leftResult = dfs(root.left);
+    NodeResult rightResult = dfs(root.right);
+    if (leftResult.distance > rightResult.distance) {
+      return new NodeResult(leftResult.node, leftResult.distance + 1);
     }
-    if (left != null) {
-      return left;
+    if (leftResult.distance < rightResult.distance) {
+      return new NodeResult(rightResult.node, rightResult.distance + 1);
     }
-    if (right != null) {
-      return right;
+    return new NodeResult(root, rightResult.distance + 1);
+  }
+  
+  private static class NodeResult {
+    TreeNode node;
+    int distance;
+    
+    public NodeResult(TreeNode node, int distance) {
+      this.node = node;
+      this.distance = distance;
     }
-    return null;
   }
 }

From e5c1fb36c9c9baaa321605b666ec7afe061dece3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 16 Sep 2022 09:17:46 -0700
Subject: [PATCH 1341/2175] Create Maximum Score from Performing Multiplication
 Operations.java

---
 ... Performing Multiplication Operations.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Maximum Score from Performing Multiplication Operations.java

diff --git a/Medium/Maximum Score from Performing Multiplication Operations.java b/Medium/Maximum Score from Performing Multiplication Operations.java
new file mode 100644
index 00000000..c197f348
--- /dev/null
+++ b/Medium/Maximum Score from Performing Multiplication Operations.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int maximumScore(int[] nums, int[] multipliers) {
+    Integer[][] dp = new Integer[1001][1001];
+    return helper(0, multipliers, nums, 0, dp);
+  }
+  
+  private int helper(int idx, int[] multipliers, int[] nums, int start, Integer[][] dp) {
+    if (idx == multipliers.length) {
+      return 0;
+    }
+    if (dp[idx][start] != null) {
+      return dp[idx][start];
+    }
+    int end = nums.length - (idx - start) - 1;
+    int startOperation = multipliers[idx] * nums[start] + helper(idx + 1, multipliers, nums, start + 1, dp); 
+    int endOperation = multipliers[idx] * nums[end] + helper(idx + 1, multipliers, nums, start, dp); 
+    return dp[idx][start] = Math.max(startOperation, endOperation);
+  }
+}

From 3d388f4f61bc0a6a7525fe99f83fb3eb00ce8772 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 17 Sep 2022 09:25:41 -0700
Subject: [PATCH 1342/2175] Update Palindrome Pairs.java

---
 Hard/Palindrome Pairs.java | 106 +++++++++++++++++++++----------------
 1 file changed, 60 insertions(+), 46 deletions(-)

diff --git a/Hard/Palindrome Pairs.java b/Hard/Palindrome Pairs.java
index a9ad8490..004bc645 100644
--- a/Hard/Palindrome Pairs.java	
+++ b/Hard/Palindrome Pairs.java	
@@ -1,54 +1,68 @@
 class Solution {
-    public List<List<Integer>> palindromePairs(String[] words) {
-        List<List<Integer>> lists = new ArrayList<>();
-        Map<String, Integer> map = new HashMap<>();
-        for (int i=0; i<words.length; i++) {
-            map.put(new StringBuilder(words[i]).reverse().toString(), i);
+  public List<List<Integer>> palindromePairs(String[] words) {
+    TrieNode root = new TrieNode();
+    for (int i = 0; i < words.length; i++) {
+      String reversed = new StringBuilder(words[i]).reverse().toString();
+      TrieNode curr = root;
+      for (int j = 0; j < reversed.length(); j++) {
+        if (isPalindrome(reversed, j)) {
+          curr.palindromePrefixRemainingIds.add(i);
         }
-
-        if (map.containsKey("")) {
-            for (int i = 0; i < words.length; i++) {
-                if (i == map.get("")) {
-                    continue;
-                }
-
-                if (palindromeCheck(words[i])) {
-                    lists.add(Arrays.asList(map.get(""), i));
-                }
-            }
+        if (!curr.children.containsKey(reversed.charAt(j))) {
+          curr.children.put(reversed.charAt(j), new TrieNode());
         }
-
-        for (int i=0; i<words.length; i++) {
-            for (int j=0; j<words[i].length(); j++) {
-                String leftPart = words[i].substring(0, j);
-                String rightPart = words[i].substring(j);
-
-                if (map.containsKey(leftPart) && palindromeCheck(rightPart) && map.get(leftPart) != i) {
-                    lists.add(Arrays.asList(i, map.get(leftPart)));
-                }
-
-                if (map.containsKey(rightPart) && palindromeCheck(leftPart) && map.get(rightPart) != i) {
-                    lists.add(Arrays.asList(map.get(rightPart), i));
-                }
-            }
+        curr = curr.children.get(reversed.charAt(j));
+      }
+      curr.wordEndingId = i;
+    }
+    List<List<Integer>> result = new ArrayList<>();
+    for (int i = 0; i < words.length; i++) {
+      String word = words[i];
+      TrieNode curr = root;
+      for (int j = 0; j < word.length(); j++) {
+        if (curr.wordEndingId != -1 && isPalindrome(word, j)) {
+          result.add(Arrays.asList(i, curr.wordEndingId));
+        }
+        char c = word.charAt(j);
+        curr = curr.children.get(c);
+        if (curr == null) {
+          break;
         }
-
-        return lists;
+      }
+      if (curr == null) {
+        continue;
+      }
+      if (curr.wordEndingId != -1 && curr.wordEndingId != i) {
+        result.add(Arrays.asList(i, curr.wordEndingId));
+      }
+      for (int idx : curr.palindromePrefixRemainingIds) {
+        result.add(Arrays.asList(i, idx));
+      }
     }
+    return result;
+  }
+  
+  private static boolean isPalindrome(String s, int start) {
+    int end = s.length() - 1;
+    while (start < end) {
+      if (s.charAt(start) != s.charAt(end)) {
+        return false;
+      }
+      start++;
+      end--;
+    }
+    return true;
+  }
+  
+  private static class TrieNode {
+    private int wordEndingId;
+    private Map<Character, TrieNode> children;
+    private List<Integer> palindromePrefixRemainingIds;
     
-    private boolean palindromeCheck(String word) {
-        int i = 0;
-        int j = word.length() - 1;
-
-        while (i < j) {
-            if (word.charAt(i) != word.charAt(j)) {
-                return false;
-            }
-
-            i++;
-            j--;
-        }
-
-        return true;
+    public TrieNode() {
+      this.wordEndingId = -1;
+      this.children = new HashMap<>();
+      this.palindromePrefixRemainingIds = new ArrayList<>();
     }
+  }
 }

From 5836759162015cc72783420c0e6da0afbc1128f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Sep 2022 07:46:08 -0700
Subject: [PATCH 1343/2175] Update Trapping Rain Water.java

---
 Hard/Trapping Rain Water.java | 39 +++++++++++++++++++++--------------
 1 file changed, 23 insertions(+), 16 deletions(-)

diff --git a/Hard/Trapping Rain Water.java b/Hard/Trapping Rain Water.java
index 6abc9416..8747d76b 100644
--- a/Hard/Trapping Rain Water.java	
+++ b/Hard/Trapping Rain Water.java	
@@ -1,20 +1,27 @@
 class Solution {
-    public int trap(int[] A) {
-        Stack<Integer> stack = new Stack<Integer>();
-        int i = 0;
-        int maxWater = 0;
-        
-        while (i < A.length){
-            if (stack.isEmpty() || A[i] <= A[stack.peek()]){
-                stack.push(i++);
-            }
-            else {
-                int bot = stack.pop();
-                maxWater += stack.isEmpty() ? 0 :
-                    (Math.min(A[stack.peek()], A[i]) - A[bot]) * (i - stack.peek() - 1);
-            }
+  public int trap(int[] height) {
+    int leftIdx = 0;
+    int rightIdx = height.length - 1;
+    int leftMax = 0;
+    int rightMax = 0;
+    int result = 0;
+    while (leftIdx < rightIdx) {
+      if (height[leftIdx] < height[rightIdx]) {
+        if (height[leftIdx] >= leftMax) {
+          leftMax = height[leftIdx];
+        } else {
+          result += leftMax - height[leftIdx];
         }
-        
-        return maxWater;
+        leftIdx++;
+      } else {
+        if (height[rightIdx] >= rightMax) {
+          rightMax = height[rightIdx];
+        } else {
+          result += rightMax - height[rightIdx];
+        }
+        rightIdx--;
+      }
     }
+    return result;
+  }
 }

From 5072c845e6b61fa11d14192beedbbddd818538c6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Sep 2022 07:58:24 -0700
Subject: [PATCH 1344/2175] Create Smallest Even Multiple.java

---
 Easy/Smallest Even Multiple.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Smallest Even Multiple.java

diff --git a/Easy/Smallest Even Multiple.java b/Easy/Smallest Even Multiple.java
new file mode 100644
index 00000000..24964eca
--- /dev/null
+++ b/Easy/Smallest Even Multiple.java	
@@ -0,0 +1,5 @@
+class Solution {
+  public int smallestEvenMultiple(int n) {
+    return n % 2 == 0 ? n : 2 * n;
+  }
+}

From 0dda7d7daa3f49c79d519b79610274e490461d7b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Sep 2022 08:02:50 -0700
Subject: [PATCH 1345/2175] Create Length of the Longest Alphabetical
 Continuous Substring.java

---
 ... Longest Alphabetical Continuous Substring.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Length of the Longest Alphabetical Continuous Substring.java

diff --git a/Medium/Length of the Longest Alphabetical Continuous Substring.java b/Medium/Length of the Longest Alphabetical Continuous Substring.java
new file mode 100644
index 00000000..30426403
--- /dev/null
+++ b/Medium/Length of the Longest Alphabetical Continuous Substring.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int longestContinuousSubstring(String s) {
+    int idx = 0;
+    int maxLength = 0;
+    while (idx < s.length()) {
+      int currIdx = idx++;
+      while (idx < s.length() && s.charAt(idx) - s.charAt(idx - 1) == 1) {
+        idx++;
+      }
+      maxLength = Math.max(maxLength, idx - currIdx);
+    }
+    return maxLength;
+  }
+}

From bf4b647842719883838761bc0e18397cb3dfda20 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Sep 2022 11:21:10 -0700
Subject: [PATCH 1346/2175] Create Reverse Odd Levels of Binary Tree.java

---
 Medium/Reverse Odd Levels of Binary Tree.java | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 Medium/Reverse Odd Levels of Binary Tree.java

diff --git a/Medium/Reverse Odd Levels of Binary Tree.java b/Medium/Reverse Odd Levels of Binary Tree.java
new file mode 100644
index 00000000..72fc142a
--- /dev/null
+++ b/Medium/Reverse Odd Levels of Binary Tree.java	
@@ -0,0 +1,55 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode reverseOddLevels(TreeNode root) {
+    int level = 0;
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      List<TreeNode> currLevel = new ArrayList<>();
+      int size = queue.size();
+      while (size-- > 0) {
+        TreeNode removed = queue.remove();
+        if (level % 2 != 0) {
+          currLevel.add(removed);
+        }
+        if (removed.left != null) {
+          queue.add(removed.left);
+        }
+        if (removed.right != null) {
+          queue.add(removed.right);
+        }
+      }
+      if (level % 2 != 0) {
+        reverseLevel(currLevel);
+      }
+      level++;
+    }
+    return root;
+  }
+  
+  private void reverseLevel(List<TreeNode> currLevel) {
+    int start = 0;
+    int end = currLevel.size() - 1;
+    while (start < end) {
+      TreeNode startNode = currLevel.get(start++);
+      TreeNode endNode = currLevel.get(end--);
+      int temp = startNode.val;
+      startNode.val = endNode.val;
+      endNode.val = temp;
+    }
+  }
+}

From cf26bc24e24aa1a58b1aea2be66425d9a9c0bb65 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Sep 2022 13:02:58 -0700
Subject: [PATCH 1347/2175] Create Maximum Matching of Players With
 Trainers.java

---
 ...Maximum Matching of Players With Trainers.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Maximum Matching of Players With Trainers.java

diff --git a/Medium/Maximum Matching of Players With Trainers.java b/Medium/Maximum Matching of Players With Trainers.java
new file mode 100644
index 00000000..5334f4e5
--- /dev/null
+++ b/Medium/Maximum Matching of Players With Trainers.java	
@@ -0,0 +1,15 @@
+class Solution {
+  public int matchPlayersAndTrainers(int[] players, int[] trainers) {
+    Arrays.sort(players);
+    Arrays.sort(trainers);
+    int playerIdx = 0;
+    int trainerIdx = 0;
+    while (playerIdx < players.length && trainerIdx < trainers.length) {
+      if (players[playerIdx] <= trainers[trainerIdx]) {
+        playerIdx++;
+      }
+      trainerIdx++;
+    }
+    return playerIdx;
+  }
+}

From c1e28be546847404bc46dad2f2f62f0feb3080e9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Sep 2022 17:22:27 -0700
Subject: [PATCH 1348/2175] Update Find Duplicate File in System.java

---
 Medium/Find Duplicate File in System.java | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/Medium/Find Duplicate File in System.java b/Medium/Find Duplicate File in System.java
index d1ff2b4c..8aa53097 100644
--- a/Medium/Find Duplicate File in System.java	
+++ b/Medium/Find Duplicate File in System.java	
@@ -1,17 +1,20 @@
 class Solution {
   public List<List<String>> findDuplicate(String[] paths) {
-    Map<String, Set<String>> map = new HashMap<>();
+    Map<String, Set<String>> contentToDirectoryMapping = new HashMap<>();
     for (String path : paths) {
-      String[] splitPath = path.split("\\s+");
-      String directory = splitPath[0];
-      for (int i = 1; i < splitPath.length; i++) {
-        String fileName = splitPath[i].substring(0, splitPath[i].indexOf('('));
-        String fileContent = splitPath[i]
-            .substring(splitPath[i].indexOf('(') + 1, splitPath[i].indexOf(')'));
-        map.computeIfAbsent(fileContent, k -> new HashSet<>()).add(directory + "/" + fileName);
+      String[] splits = path.split("\\s+");
+      String directoryName = splits[0];
+      for (int i = 1; i < splits.length; i++) {
+        int contentStartIdx = splits[i].indexOf('(');
+        String fileName = splits[i].substring(0, contentStartIdx);
+        String content = splits[i].substring(contentStartIdx + 1, splits[i].length() - 1);
+        contentToDirectoryMapping.computeIfAbsent(content, k -> new HashSet<>())
+          .add(directoryName + "/" + fileName);
       }
     }
-    return map.values().stream().filter(entry -> entry.size() > 1).map(ArrayList::new)
-        .collect(Collectors.toList());
+    return contentToDirectoryMapping.values().stream()
+      .filter(e -> e.size() > 1)
+      .map(ArrayList::new)
+      .collect(Collectors.toList());
   }
 }

From fef44ff827838ece14977cd66e8af3c96e901c19 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 19 Sep 2022 10:23:24 -0700
Subject: [PATCH 1349/2175] Update Reconstruct Itinerary.java

---
 Hard/Reconstruct Itinerary.java | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/Hard/Reconstruct Itinerary.java b/Hard/Reconstruct Itinerary.java
index 26629d58..0c3c962f 100644
--- a/Hard/Reconstruct Itinerary.java	
+++ b/Hard/Reconstruct Itinerary.java	
@@ -1,20 +1,22 @@
 class Solution {
   public List<String> findItinerary(List<List<String>> tickets) {
-    LinkedList<String> itinerary = new LinkedList<>();
-    Map<String, PriorityQueue<String>> graph = new HashMap<>();
-    Stack<String> stack = new Stack<>();
+    Map<String, PriorityQueue<String>> map = new HashMap<>();
     for (List<String> ticket : tickets) {
-      graph.computeIfAbsent(ticket.get(0), k -> new PriorityQueue<>()).add(ticket.get(1));
+      String from = ticket.get(0);
+      String to = ticket.get(1);
+      map.computeIfAbsent(from, k -> new PriorityQueue<>()).add(to);
     }
+    Stack<String> stack = new Stack<>();
+    LinkedList<String> result = new LinkedList<>();
     stack.push("JFK");
     while (!stack.isEmpty()) {
-      String nextDestination = stack.peek();
-      if (!graph.getOrDefault(nextDestination, new PriorityQueue<>()).isEmpty()) {
-        stack.push(graph.get(nextDestination).poll());
+      String destination = stack.peek();
+      if (!map.getOrDefault(destination, new PriorityQueue<>()).isEmpty()) {
+        stack.push(map.get(destination).remove());
       } else {
-        itinerary.addFirst(stack.pop());
+        result.addFirst(stack.pop());
       }
     }
-    return itinerary;
+    return result;
   }
 }

From b66ddaa489dcfee59566f57a07ba62d0f71e54ef Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 19 Sep 2022 10:26:58 -0700
Subject: [PATCH 1350/2175] Update Kth Smallest Element in a BST.java

---
 Medium/Kth Smallest Element in a BST.java | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/Medium/Kth Smallest Element in a BST.java b/Medium/Kth Smallest Element in a BST.java
index 74cb3112..6f77e133 100644
--- a/Medium/Kth Smallest Element in a BST.java	
+++ b/Medium/Kth Smallest Element in a BST.java	
@@ -15,17 +15,21 @@
  */
 class Solution {
   public int kthSmallest(TreeNode root, int k) {
+    Integer result = null;
     Stack<TreeNode> stack = new Stack<>();
-    while (true) {
-      while (root != null) {
-        stack.push(root);
-        root = root.left;
-      }
-      root = stack.pop();
-      if (--k == 0) {
-        return root.val;
+    while (root != null) {
+      stack.push(root);
+      root = root.left;
+    }
+    while (k > 1 && !stack.isEmpty()) {
+      TreeNode removed = stack.pop();
+      TreeNode rightNode = removed.right;
+      while (rightNode != null) {
+        stack.push(rightNode);
+        rightNode = rightNode.left;
       }
-      root = root.right;
+      k--;
     }
+    return stack.peek().val;
   }
 }

From fc6f2c8793a032ba59fe11071fc1c09e45b92335 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Sep 2022 08:49:15 -0700
Subject: [PATCH 1351/2175] Update Minimum Index Sum of Two Lists.java

---
 Easy/Minimum Index Sum of Two Lists.java | 28 ++++++++++++------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Easy/Minimum Index Sum of Two Lists.java b/Easy/Minimum Index Sum of Two Lists.java
index 1a11f2d3..0333614d 100644
--- a/Easy/Minimum Index Sum of Two Lists.java	
+++ b/Easy/Minimum Index Sum of Two Lists.java	
@@ -4,25 +4,25 @@ public String[] findRestaurant(String[] list1, String[] list2) {
     for (int i = 0; i < list1.length; i++) {
       map.put(list1[i], i);
     }
-    List<String> list = new ArrayList<>();
     int minIndexSum = Integer.MAX_VALUE;
+    Map<String, Integer> stringToIndexSum = new HashMap<>();
     for (int i = 0; i < list2.length; i++) {
       if (map.containsKey(list2[i])) {
-        int indexSum = map.get(list2[i]) + i;
-        if (indexSum < minIndexSum) {
-          minIndexSum = indexSum;
-          list = new ArrayList<>();
-          list.add(list2[i]);
-        }
-        else if (indexSum == minIndexSum) {
-          list.add(list2[i]);
-        }
+        int indexSum = i + map.get(list2[i]);
+        minIndexSum = Math.min(minIndexSum, indexSum);
+        stringToIndexSum.put(list2[i], indexSum);
       }
     }
-    String[] ans = new String[list.size()];
-    for (int i = 0; i < list.size(); i++) {
-      ans[i] = list.get(i);
+    List<String> result = new ArrayList<>();
+    for (String key : stringToIndexSum.keySet()) {
+      if (stringToIndexSum.get(key) == minIndexSum) {
+        result.add(key);
+      }
+    }
+    String[] resultArr = new String[result.size()];
+    for (int i = 0; i < result.size(); i++) {
+      resultArr[i] = result.get(i);
     }
-    return ans;
+    return resultArr;
   }
 }

From ede04e0150f07e34916f326458993eae5326ec7c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Sep 2022 13:05:14 -0700
Subject: [PATCH 1352/2175] Update Battleships in a board.java

---
 Medium/Battleships in a board.java | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/Medium/Battleships in a board.java b/Medium/Battleships in a board.java
index 37d19242..d84273bc 100644
--- a/Medium/Battleships in a board.java	
+++ b/Medium/Battleships in a board.java	
@@ -1,20 +1,17 @@
 class Solution {
-    public int countBattleships(char[][] board) {
-        int n = board.length;
-        if (n == 0) return 0;
-        int m = board[0].length;
-        
-        int count = 0;
-        for (int i=0;i<n;i++) {
-            for (int j=0;j<m;j++) {
-                if (board[i][j] == '.') continue;
-                if (i > 0 && board[i-1][j] == 'X')continue;
-                if (j > 0 && board[i][j-1] == 'X')continue;
-                
-                count++;
-            }
+  
+  public int countBattleships(char[][] board) {
+    int count = 0;
+    int rows = board.length;
+    int cols = board[0].length;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (board[i][j] == '.' || (i > 0 && board[i - 1][j] == 'X') || (j > 0 && board[i][j - 1] == 'X')) {
+          continue;
         }
-        
-        return count;
+        count++;
+      }
     }
+    return count;
+  }
 }

From b1eb90d0a82d11b14fc0772587d71a95fe3c9514 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Sep 2022 14:17:20 -0700
Subject: [PATCH 1353/2175] Create Lexicographically Smallest Equivalent
 String.java

---
 ...raphically Smallest Equivalent String.java | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Lexicographically Smallest Equivalent String.java

diff --git a/Medium/Lexicographically Smallest Equivalent String.java b/Medium/Lexicographically Smallest Equivalent String.java
new file mode 100644
index 00000000..c5856615
--- /dev/null
+++ b/Medium/Lexicographically Smallest Equivalent String.java	
@@ -0,0 +1,31 @@
+class Solution {
+  public String smallestEquivalentString(String s1, String s2, String baseStr) {
+    int[] graph = new int[26];
+    for (int i = 0; i < 26; i++) {
+      graph[i] = i;
+    }
+    for (int i = 0; i < s1.length(); i++) {
+      int idxOne = s1.charAt(i) - 'a';
+      int idxTwo = s2.charAt(i) - 'a';
+      int parentOne = find(graph, idxOne);
+      int parentTwo = find(graph, idxTwo);
+      if(parentOne < parentTwo) {
+        graph[parentTwo] = parentOne;
+      } else {
+        graph[parentOne] = parentTwo;
+      }
+    }
+    StringBuilder sb = new StringBuilder();
+    for (char c : baseStr.toCharArray()) {
+      sb.append((char) ('a' + find(graph, c - 'a')));
+    }
+    return sb.toString();
+  }
+  
+  private int find(int[] graph, int idx) {
+    while(graph[idx] != idx) {
+      idx = graph[idx];
+    }
+    return idx;
+  }
+}

From 9fa41cfdd5b1f2ba38a5824197316843c2eb6cfd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Sep 2022 15:21:12 -0700
Subject: [PATCH 1354/2175] Update Maximize Distance to Closest Person.java

---
 .../Maximize Distance to Closest Person.java  | 30 +++++--------------
 1 file changed, 7 insertions(+), 23 deletions(-)

diff --git a/Medium/Maximize Distance to Closest Person.java b/Medium/Maximize Distance to Closest Person.java
index 7b65d4de..8816dda5 100644
--- a/Medium/Maximize Distance to Closest Person.java	
+++ b/Medium/Maximize Distance to Closest Person.java	
@@ -1,30 +1,14 @@
 class Solution {
   public int maxDistToClosest(int[] seats) {
-    int numberOfSeats = seats.length;
-    int[] distanceFromRight = new int[numberOfSeats];
-    int[] distanceFromLeft = new int[numberOfSeats];
-    for (int i = 1; i < numberOfSeats; i++) {
-      if (seats[i - 1] == 0 && seats[i] == 0) {
-          distanceFromLeft[i] = distanceFromLeft[i - 1] + 1;
-      }
-    }
-    for (int i = numberOfSeats - 2; i >= 0; i--) {
-      if (seats[i + 1] != 1 && seats[i] == 0) {
-          distanceFromRight[i] = distanceFromRight[i + 1] + 1;
-      }
-    }
+    int n = seats.length;
     int maxDistance = 0;
-    for (int i = 0; i < numberOfSeats; i++) {
-      if (i == 0 || i == numberOfSeats - 1) {
-        maxDistance = Math.max(
-          maxDistance, Math.max(distanceFromLeft[i], distanceFromRight[i])
-        );
-      } else {
-        maxDistance = Math.max(
-          maxDistance, Math.min(distanceFromLeft[i], distanceFromRight[i])
-        );
+    int start = -1;
+    for (int i = 0; i < n; i++) {
+      if (seats[i] == 1) {
+        maxDistance = start == -1 ? i : Math.max(maxDistance, (i - start) / 2);
+        start = i;
       }
     }
-    return maxDistance + 1;
+    return Math.max(maxDistance, n - 1 - start);
   }
 }

From 5b60dada664921fd11484f28a3fc6d3e16cfd26e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Sep 2022 15:51:09 -0700
Subject: [PATCH 1355/2175] Update and rename Easy/Rotated Digits.java to
 Medium/Rotated Digits.java

---
 Easy/Rotated Digits.java   | 30 ------------------------------
 Medium/Rotated Digits.java | 25 +++++++++++++++++++++++++
 2 files changed, 25 insertions(+), 30 deletions(-)
 delete mode 100644 Easy/Rotated Digits.java
 create mode 100644 Medium/Rotated Digits.java

diff --git a/Easy/Rotated Digits.java b/Easy/Rotated Digits.java
deleted file mode 100644
index 2bc9a2dc..00000000
--- a/Easy/Rotated Digits.java	
+++ /dev/null
@@ -1,30 +0,0 @@
-class Solution {
-  public int rotatedDigits(int N) {
-    int count = 0;
-    for (int i = 1; i <= N; i++) {
-      if (isGood(String.valueOf(i))) {
-        count++;
-      }
-    }
-    return count;
-  } 
-  
-  private boolean isGood(String num) {
-    StringBuilder sb = new StringBuilder();
-    for (char c : num.toCharArray()) {
-      if (c == '0' || c == '1' || c == '8') {
-        sb.append(c);
-      }
-      else if (c == '2' || c == '5') {
-        sb.append(c == '2' ? '5' : '2');
-      }
-      else if (c == '6' || c == '9') {
-        sb.append(c == '6' ? '9' : '6');
-      }
-      else {
-        return false;
-      }
-    }
-    return !sb.toString().equals(num);
-  }
-}
diff --git a/Medium/Rotated Digits.java b/Medium/Rotated Digits.java
new file mode 100644
index 00000000..5d0104e8
--- /dev/null
+++ b/Medium/Rotated Digits.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int rotatedDigits(int n) {
+    int[] dp = new int[n + 1];
+    int result = 0;
+    for (int i = 0; i <= Math.min(n, 9); i++) {
+      if (i == 0 || i == 1 || i == 8) {
+        dp[i] = 1;
+      } else if (i == 2 || i == 5 || i == 6 || i == 9) {
+        dp[i] = 2;
+        result++;
+      }
+    }
+    for (int i = 10; i <= n; i++) {
+      int factor = dp[i / 10];
+      int remainder = dp[i % 10];
+      if (factor == 1 && remainder == 1) {
+        dp[i] = 1;
+      } else if (factor >= 1 && remainder >= 1) {
+        dp[i] = 2;
+        result++;
+      }
+    }
+    return result;
+  }
+}

From 665277b465b02ccb9b5635361b9466b91b351420 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Sep 2022 20:03:32 -0700
Subject: [PATCH 1356/2175] Create Balance a Binary Search Tree.java

---
 Medium/Balance a Binary Search Tree.java | 42 ++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Balance a Binary Search Tree.java

diff --git a/Medium/Balance a Binary Search Tree.java b/Medium/Balance a Binary Search Tree.java
new file mode 100644
index 00000000..9fbf14ce
--- /dev/null
+++ b/Medium/Balance a Binary Search Tree.java	
@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode balanceBST(TreeNode root) {
+    List<Integer> sortedList = new ArrayList<>();
+    inorderTraversal(root, sortedList);
+    return buildBST(sortedList, 0, sortedList.size() - 1);
+  }   
+  
+  private TreeNode buildBST(List<Integer> sortedList, int start, int end) {
+    if (start > end) {
+      return null;
+    }
+    int mid = (start + end) / 2;
+    TreeNode root = new TreeNode(sortedList.get(mid));
+    root.left = buildBST(sortedList, start, mid - 1);
+    root.right = buildBST(sortedList, mid + 1, end);
+    return root;
+  }
+  
+  private void inorderTraversal(TreeNode root, List<Integer> sortedList) {
+    if (root == null) {
+      return;
+    }
+    inorderTraversal(root.left, sortedList);
+    sortedList.add(root.val);
+    inorderTraversal(root.right, sortedList);
+  }
+}

From f6a8777afae84facfdb3a62d26c2527c11642c18 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Sep 2022 07:03:45 -0700
Subject: [PATCH 1357/2175] Update Set Matrix Zeroes.java

---
 Medium/Set Matrix Zeroes.java | 35 +++++++++++++++--------------------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/Medium/Set Matrix Zeroes.java b/Medium/Set Matrix Zeroes.java
index 5aad58c2..d2a2e67a 100644
--- a/Medium/Set Matrix Zeroes.java	
+++ b/Medium/Set Matrix Zeroes.java	
@@ -1,55 +1,50 @@
 class Solution {
   public void setZeroes(int[][] matrix) {
+    int rows = matrix.length;
+    int cols = matrix[0].length;
     boolean firstRowZero = false;
     boolean firstColZero = false;
-    int numRows = matrix.length;
-    int numCols = matrix[0].length;
-    // Mark if first column needs to be set zero
-    for (int i = 0; i < numRows; i++) {
+    for (int i = 0; i < rows; i++) {
       if (matrix[i][0] == 0) {
         firstColZero = true;
+        break;
       }
     }
-    // Mark if first row needs to be set zero
-    for (int i = 0; i < numCols; i++) {
+    for (int i = 0; i < cols; i++) {
       if (matrix[0][i] == 0) {
         firstRowZero = true;
+        break;
       }
     }
-    // If a value in matrix is zero set the value at first row and column to be zero
-    for (int i = 1; i < numRows; i++) {
-      for (int j = 1; j < numCols; j++) {
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
         if (matrix[i][j] == 0) {
           matrix[0][j] = 0;
           matrix[i][0] = 0;
         }
       }
     }
-    // Update the complete column to be zero if first item of row is zero
-    for (int i = 1; i < numRows; i++) {
+    for (int i = 1; i < rows; i++) {
       if (matrix[i][0] == 0) {
-        for (int j = 1; j < numCols; j++) {
+        for (int j = 0; j < cols; j++) {
           matrix[i][j] = 0;
         }
       }
     }
-    // Update the complete row to be zero if first item of column is zero
-    for (int i = 1; i < numCols; i++) {
+    for (int i = 1; i < cols; i++) {
       if (matrix[0][i] == 0) {
-        for (int j = 1; j < numRows; j++) {
+        for (int j = 0; j < rows; j++) {
           matrix[j][i] = 0;
         }
-      } 
+      }
     }
-    // Set the first row to zero if flag is set
     if (firstRowZero) {
-      for (int i = 0; i < numCols; i++) {
+      for (int i = 0; i < cols; i++) {
         matrix[0][i] = 0;
       }
     }
-    // Set the first column to zero if flag is set
     if (firstColZero) {
-      for (int i = 0; i < numRows; i++) {
+      for (int i = 0; i < rows; i++) {
         matrix[i][0] = 0;
       }
     }

From 2ba8f62ad50f50724cef165f9906c905023424d2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Sep 2022 12:59:24 -0700
Subject: [PATCH 1358/2175] Update Next Closest Time.java

---
 Medium/Next Closest Time.java | 55 ++++++++++++-----------------------
 1 file changed, 18 insertions(+), 37 deletions(-)

diff --git a/Medium/Next Closest Time.java b/Medium/Next Closest Time.java
index 0d1ef172..46e267f6 100644
--- a/Medium/Next Closest Time.java	
+++ b/Medium/Next Closest Time.java	
@@ -1,42 +1,23 @@
 class Solution {
-    public String nextClosestTime(String time) {
-        char[] timeDigits = time.toCharArray();
-        char[] sorted = time.toCharArray();
-        Arrays.sort(sorted);
-        
-        timeDigits[4] = findNext(timeDigits[4], (char)('9' + 1), sorted);
-        if (timeDigits[4] > time.charAt(4)) {
-            return String.valueOf(timeDigits);
-        }
-        
-        timeDigits[3] = findNext(timeDigits[3], '5', sorted);
-        if (timeDigits[3] > time.charAt(3)) {
-            return String.valueOf(timeDigits);
-        }
-        
-        timeDigits[1] = timeDigits[0] == '2' ? 
-                                findNext(timeDigits[1], '3', sorted) : 
-                                findNext(timeDigits[1], (char)('9' + 1), sorted);
-        if (timeDigits[1] > time.charAt(1)) {
-            return String.valueOf(timeDigits);
-        }
-        
-        timeDigits[0] = findNext(timeDigits[0], '2', sorted);
-        
-        return String.valueOf(timeDigits);
+  public String nextClosestTime(String time) {
+    int minutes = Integer.parseInt(time.substring(0, 2)) * 60 + Integer.parseInt(time.substring(3));
+    Set<Integer> digits = new HashSet<>();
+    for (char c : time.toCharArray()) {
+      digits.add(c - '0');
     }
-    
-    private char findNext(char current, char limit, char[] sorted) {
-        if (current == limit) {
-            return sorted[0];
-        }
-        
-        int pos = Arrays.binarySearch(sorted, current) + 1;
-        
-        while (pos < 4 && (sorted[pos] > limit || sorted[pos] == current)) {
-            pos++;
+    while (true) {
+      minutes = (minutes + 1) % (24 * 60);
+      int[] nextTime = {minutes / 60 / 10, minutes / 60 % 10, minutes % 60 / 10, minutes % 60 % 10};
+      boolean found = true;
+      for (int unit : nextTime) {
+        if (!digits.contains(unit)) {
+          found = false;
+          break;
         }
-        
-        return pos == 4 ? sorted[0] : sorted[pos];
+      }
+      if (found) {
+        return String.format("%02d:%02d", minutes / 60, minutes % 60);
+      }
     }
+  }
 }

From 84ece1d79c1e15425ea18b16b2de1350ea2d60af Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Sep 2022 13:05:29 -0700
Subject: [PATCH 1359/2175] Update K Empty Slots.java

---
 Hard/K Empty Slots.java | 36 ++++++++++++++++++++----------------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/Hard/K Empty Slots.java b/Hard/K Empty Slots.java
index 6b004bf0..bb499351 100644
--- a/Hard/K Empty Slots.java	
+++ b/Hard/K Empty Slots.java	
@@ -1,19 +1,23 @@
 class Solution {
-    public int kEmptySlots(int[] flowers, int k) {
-        TreeSet<Integer> set = new TreeSet<>();
-        int day = 0;
-
-        for (int flower : flowers) {
-            day++;
-            set.add(flower);
-            Integer lower = set.lower(flower);
-            Integer higher = set.higher(flower);
-
-            if ((lower != null && flower - lower - 1 == k) || (higher != null && higher - flower - 1 == k)) {
-                return day;
-            }
-        }
-
-        return -1;
+  public int kEmptySlots(int[] bulbs, int k) {
+    int n = bulbs.length;
+    int[] position = new int[n + 1];
+    for (int i = 0; i < n; i++) {
+      position[bulbs[i]] = i;
     }
+    int result = Integer.MAX_VALUE;
+    int start = 1;
+    int end = k + 2;
+    for (int i = 1; end <= n; i++) {
+      if (position[i] > position[start] && position[i] > position[end]) {
+        continue;
+      }
+      if (i == end) {
+        result = Math.min(result, Math.max(position[start], position[end]) + 1);
+      }
+      start = i;
+      end = k + 1 + i;
+    }
+    return result == Integer.MAX_VALUE ? -1 : result;
+  }
 }

From 637ceb6a6efdb4a2be59d8e04cdeb4c475bc418c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Sep 2022 13:40:03 -0700
Subject: [PATCH 1360/2175] Update and rename Easy/Largest Time for Given
 Digits.java to Medium/Largest Time for Given Digits.java

---
 Easy/Largest Time for Given Digits.java   | 25 -----------------
 Medium/Largest Time for Given Digits.java | 33 +++++++++++++++++++++++
 2 files changed, 33 insertions(+), 25 deletions(-)
 delete mode 100644 Easy/Largest Time for Given Digits.java
 create mode 100644 Medium/Largest Time for Given Digits.java

diff --git a/Easy/Largest Time for Given Digits.java b/Easy/Largest Time for Given Digits.java
deleted file mode 100644
index 51ab3232..00000000
--- a/Easy/Largest Time for Given Digits.java	
+++ /dev/null
@@ -1,25 +0,0 @@
-class Solution {
-  public String largestTimeFromDigits(int[] A) {
-    int ans = -1;
-    for (int i = 0; i < 4; i++) {
-      for (int j = 0; j < 4; j++) {
-        if (i != j) {
-          for (int k = 0; k < 4; k++) {
-            if (i != k && j != k) {
-              for (int l = 0; l < 4; l++) {
-                if (l != i && l != j && l != k) {
-                  int hours = 10 * A[i] + A[j];
-                  int mins = 10 * A[k] + A[l];
-                  if (hours < 24 && mins < 60) {
-                    ans = Math.max(ans, hours * 60 + mins);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    return ans >= 0 ? String.format("%02d:%02d", ans / 60, ans % 60) : "";
-  }
-}
diff --git a/Medium/Largest Time for Given Digits.java b/Medium/Largest Time for Given Digits.java
new file mode 100644
index 00000000..ca920ebb
--- /dev/null
+++ b/Medium/Largest Time for Given Digits.java	
@@ -0,0 +1,33 @@
+class Solution {
+  public String largestTimeFromDigits(int[] arr) {
+    int[] maxTime = {-1};
+    permute(arr, 0, maxTime);
+    return maxTime[0] == -1 ? "" : String.format("%02d:%02d", maxTime[0] / 60, maxTime[0] % 60);
+  }
+  
+  private void permute(int[] arr, int idx, int[] maxTime) {
+    if (idx == arr.length) {
+      buildTime(arr, maxTime);
+      return;
+    }
+    for (int i = idx; i < arr.length; i++) {
+      swap(arr, i, idx);
+      permute(arr, idx + 1, maxTime);
+      swap(arr, idx, i);
+    }
+  }
+  
+  private void buildTime(int[] arr, int[] maxTime) {
+    int hour = arr[0] * 10 + arr[1];
+    int minutes = arr[2] * 10 + arr[3];
+    if (hour < 24 && minutes < 60) {
+      maxTime[0] = Math.max(maxTime[0], hour * 60 + minutes);
+    }
+  }
+  
+  private void swap(int[] arr, int i, int j) {
+    int temp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = temp;
+  }
+}

From 594418682531b97b9be8612765111058481bdc28 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Sep 2022 13:49:41 -0700
Subject: [PATCH 1361/2175] Update Range Sum Query - Mutable.java

---
 Medium/Range Sum Query - Mutable.java | 59 +++++++++++++++------------
 1 file changed, 32 insertions(+), 27 deletions(-)

diff --git a/Medium/Range Sum Query - Mutable.java b/Medium/Range Sum Query - Mutable.java
index 5faab61f..d57769f2 100644
--- a/Medium/Range Sum Query - Mutable.java	
+++ b/Medium/Range Sum Query - Mutable.java	
@@ -1,45 +1,50 @@
 class NumArray {
-  
+
+  private BIT bit;
   private int[] nums;
-  private int[] indexTree;
-  private int n;
   
   public NumArray(int[] nums) {
+    this.bit = new BIT(nums.length);
     this.nums = nums;
-    this.n = nums.length;
-    this.indexTree = new int[n + 1];
-    for (int i = 0; i < n; i++) {
-      initialize(i, nums[i]);
+    for (int i = 0; i < nums.length; i++) {
+      this.bit.update(i + 1, nums[i]);
     }
   }
 
   public void update(int index, int val) {
-    int diff = val - this.nums[index];
-		this.nums[index] = val;
-		initialize(index, diff);
+    int delta = val - nums[index];
+    this.bit.update(index + 1, delta);
+    this.nums[index] = val;
   }
 
   public int sumRange(int left, int right) {
-    return getSum(right) - getSum(left - 1);
+    return this.bit.query(right + 1) - this.bit.query(left);
   }
   
-  private void initialize(int idx, int value) {
-		idx++;
-		while (idx <= this.n) {
-			this.indexTree[idx] += value;
-			idx += (idx & -idx);
-		}
+  private static class BIT {
+    
+    private int[] sum;
+    
+    public BIT(int n) {
+      this.sum = new int[n + 1];
+    }
+    
+    private void update(int idx, int delta) {
+      while (idx < sum.length) {
+        sum[idx] += delta;
+        idx += (idx & -idx);
+      }
+    }
+    
+    private int query(int idx) {
+      int result = 0;
+      while (idx > 0) {
+        result += sum[idx];
+        idx -= (idx & -idx); 
+      }
+      return result;
+    }
   }
-  
-  private int getSum(int i) {
-		int sum = 0;
-		i++;
-		while (i > 0) {
-			sum += this.indexTree[i];
-			i -= (i & -i);
-		}
-		return sum;
-	}
 }
 
 /**

From a9e088d67ac8a96d0ae599c6f0f524b6bd4d4ac5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Sep 2022 18:56:56 -0700
Subject: [PATCH 1362/2175] Update Remove Interval.java

---
 Medium/Remove Interval.java | 51 ++++++++++---------------------------
 1 file changed, 14 insertions(+), 37 deletions(-)

diff --git a/Medium/Remove Interval.java b/Medium/Remove Interval.java
index 4ebbcf9e..0405621d 100644
--- a/Medium/Remove Interval.java	
+++ b/Medium/Remove Interval.java	
@@ -1,41 +1,18 @@
 class Solution {
-    public List<List<Integer>> removeInterval(int[][] intervals, int[] toBeRemoved) {
-        List<List<Integer>> list = new ArrayList<>();
-        int removeStart = toBeRemoved[0];
-        int removeEnd = toBeRemoved[1];
-        for (int[] interval : intervals) {
-            int start = interval[0];
-            int end = interval[1];
-            // Case 1: Overlap the removal interval. Skip this interval
-            if (start >= removeStart && end <= removeEnd) {
-                continue;
-            }
-            // Case 2 and 3: Completely miss out the removal interval either on left side or right side of number line.
-            // Add the complete interval
-            if ((start <= removeStart && end <= removeStart) ||
-                (start >= removeEnd && end >= removeEnd)) {
-                list.add(Arrays.asList(start, end));
-                continue;
-            }
-            // Case 4: Interval partially overlaps on left side of removal interval on number line. 
-            // Add the modified interval
-            if (start <= removeStart) {
-                int tempStart = Math.min(start, removeStart);
-                int tempEnd = Math.max(start, removeStart);
-                if (tempStart != tempEnd) {
-                    list.add(Arrays.asList(tempStart, tempEnd));
-                }
-            }
-            // Case 5: Interval partially overlaps on right side of removal interval on number line. 
-            // Add the modified interval
-            if (end >= removeEnd) {
-                int tempStart = Math.min(end, removeEnd);
-                int tempEnd = Math.max(end, removeEnd);
-                if (tempStart != tempEnd) {
-                    list.add(Arrays.asList(tempStart, tempEnd));
-                }
-            }
+  public List<List<Integer>> removeInterval(int[][] intervals, int[] toBeRemoved) {
+    List<List<Integer>> result = new ArrayList<>();
+    for (int[] interval : intervals) {
+      if (interval[0] > toBeRemoved[1] || interval[1] < toBeRemoved[0]) {
+        result.add(Arrays.asList(interval[0], interval[1]));
+      } else {
+        if (interval[0] < toBeRemoved[0]) {
+          result.add(Arrays.asList(interval[0], toBeRemoved[0]));
         }
-        return list;
+        if (interval[1] > toBeRemoved[1]) {
+          result.add(Arrays.asList(toBeRemoved[1], interval[1]));
+        }
+      }
     }
+    return result;
+  } 
 }

From 8d30bd80b8050b612c9e6c05e048d4038cb5cb80 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Sep 2022 19:11:56 -0700
Subject: [PATCH 1363/2175] Update Reorder List.java

---
 Medium/Reorder List.java | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/Medium/Reorder List.java b/Medium/Reorder List.java
index f67b973c..769a555d 100644
--- a/Medium/Reorder List.java	
+++ b/Medium/Reorder List.java	
@@ -10,21 +10,15 @@
  */
 class Solution {
   public void reorderList(ListNode head) {
-    if (head.next == null) {
-      return;
-    }
-    // Find mid point
     ListNode slow = head;
     ListNode fast = head;
     while (fast != null && fast.next != null) {
-      fast = fast.next.next;
       slow = slow.next;
+      fast = fast.next.next;
     }
-    // Reverse the second half & break the two halves
     ListNode secondHalf = reverse(slow.next);
     slow.next = null;
     ListNode firstHalf = head;
-    // Merge first half and second half
     while (firstHalf != null && secondHalf != null) {
       ListNode firstHalfNext = firstHalf.next;
       ListNode secondHalfNext = secondHalf.next;
@@ -35,12 +29,11 @@ public void reorderList(ListNode head) {
     }
   }
   
-  private ListNode reverse(ListNode head) {
-    ListNode curr = head;
-    ListNode next = null;
+  private ListNode reverse(ListNode node) {
+    ListNode curr = node;
     ListNode prev = null;
     while (curr != null) {
-      next = curr.next;
+      ListNode next = curr.next;
       curr.next = prev;
       prev = curr;
       curr = next;

From 6b1710eec2b6bc96ac7d5dc4a77830c0ed38fce0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Sep 2022 19:38:56 -0700
Subject: [PATCH 1364/2175] Update Lonely Pixel I.java

---
 Medium/Lonely Pixel I.java | 52 +++++++++++++++-----------------------
 1 file changed, 20 insertions(+), 32 deletions(-)

diff --git a/Medium/Lonely Pixel I.java b/Medium/Lonely Pixel I.java
index ae676662..42ae180d 100644
--- a/Medium/Lonely Pixel I.java	
+++ b/Medium/Lonely Pixel I.java	
@@ -1,37 +1,25 @@
 class Solution {
-    public int findLonelyPixel(char[][] picture) {
-        int count = 0;
-        Map<Integer, Integer> rowMap = new HashMap<>();
-
-        for (int i=0; i<picture.length; i++) {
-            rowMap.put(i, 0);
-            for (int j=0; j<picture[i].length; j++) {
-                if (picture[i][j] == 'B') {
-                    rowMap.put(i, rowMap.get(i) + 1);
-                }
-            }
+  public int findLonelyPixel(char[][] picture) {
+    int rows = picture.length;
+    int cols = picture[0].length;
+    Map<Integer, Integer> rowMap = new HashMap<>();
+    Map<Integer, Integer> colMap = new HashMap<>();
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (picture[i][j] == 'B') {
+          rowMap.put(i, rowMap.getOrDefault(i, 0) + 1);
+          colMap.put(j, colMap.getOrDefault(j, 0) + 1);
         }
-
-        Map<Integer, Integer> colMap = new HashMap<>();
-        for (int i=0; i<picture[0].length; i++) {
-            colMap.put(i, 0);
-            for (int j=0; j<picture.length; j++) {
-                if (picture[j][i] == 'B') {
-                    colMap.put(i, colMap.get(i) + 1);
-                }
-            }
-        }
-
-        for (int i=0; i<picture.length; i++) {
-            for (int j=0; j<picture[0].length; j++) {
-                if (picture[i][j] == 'B') {
-                    if (rowMap.get(i) == 1 && colMap.get(j) == 1) {
-                        count++;
-                    }
-                }
-            }
+      }
+    }
+    int count = 0;
+    for (int i = 0; i < rows; i++) {
+      for (int j = 0; j < cols; j++) {
+        if (picture[i][j] == 'B' && rowMap.get(i) == 1 && colMap.get(j) == 1) {
+          count++;
         }
-
-        return count;
+      }
     }
+    return count;
+  } 
 }

From 498a94f77cfcd3100d9122e253bb0fd9c2c2fded Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 22 Sep 2022 16:06:43 -0700
Subject: [PATCH 1365/2175] Update Lemonade Change.java

---
 Easy/Lemonade Change.java | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/Easy/Lemonade Change.java b/Easy/Lemonade Change.java
index ec201343..acddd319 100644
--- a/Easy/Lemonade Change.java	
+++ b/Easy/Lemonade Change.java	
@@ -1,23 +1,22 @@
 class Solution {
   public boolean lemonadeChange(int[] bills) {
-    final int LEMONADE_COST = 5;
-    int[] billDenominations = {20, 10, 5};
-    Map<Integer, Integer> cashCounter = new HashMap<>();
+    int[] billCount = new int[3];
     for (int bill : bills) {
-      int changeRequired = bill - LEMONADE_COST;
-      cashCounter.put(bill, cashCounter.getOrDefault(bill, 0) + 1);
-      for (Integer denomination : billDenominations) {
-        int numOfBills = Math.min(
-            changeRequired / denomination, cashCounter.getOrDefault(denomination, 0)
-        );
-        changeRequired -= denomination * numOfBills;
-        cashCounter.put(
-          denomination, cashCounter.getOrDefault(denomination, 0) - numOfBills
-        );
+      int returnAmount = bill - 5;
+      for (int i = 2; i >= 0 && returnAmount > 0; i--) {
+        int amount = i == 2 ? 20 : (i == 1 ? 10 : 5);
+        if (returnAmount >= amount) {
+          int billsRequired = returnAmount / amount;
+          int billsAvailable = billCount[i];
+          returnAmount -= Math.min(billsRequired, billsAvailable) * amount;
+          billCount[i] -= Math.min(billsRequired, billsAvailable);
+        }
       }
-      if (changeRequired > 0) {
+      if (returnAmount != 0) {
         return false;
       }
+      int amountIdx = bill == 20 ? 2 : (bill == 10 ? 1 : 0);
+      billCount[amountIdx]++;
     }
     return true;
   }

From 1f4c7f235442e827b79fa533704340792042054e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 23 Sep 2022 06:15:32 -0700
Subject: [PATCH 1366/2175] Create Concatenation of Consecutive Binary
 Numbers.java

---
 ...oncatenation of Consecutive Binary Numbers.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Concatenation of Consecutive Binary Numbers.java

diff --git a/Medium/Concatenation of Consecutive Binary Numbers.java b/Medium/Concatenation of Consecutive Binary Numbers.java
new file mode 100644
index 00000000..fa27285f
--- /dev/null
+++ b/Medium/Concatenation of Consecutive Binary Numbers.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public int concatenatedBinary(int n) {
+    final int MOD = 1000_000_007;
+    int length = 0;
+    long result = 0;
+    for (int i = 1; i <= n; i++) {
+      if (Math.pow(2, (int) (Math.log(i) / Math.log(2))) == i) {
+        length++;
+      }
+      result = ((result * (int) Math.pow(2, length)) + i) % MOD;
+    }
+    return (int) result;
+  }
+}

From bdbce0f828ecae41857afe3dd3c05281c92868db Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 23 Sep 2022 06:53:26 -0700
Subject: [PATCH 1367/2175] Update Finding the Users Active Minutes.java

---
 Medium/Finding the Users Active Minutes.java | 24 +++++++-------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/Medium/Finding the Users Active Minutes.java b/Medium/Finding the Users Active Minutes.java
index 40d877af..45c9c86c 100644
--- a/Medium/Finding the Users Active Minutes.java	
+++ b/Medium/Finding the Users Active Minutes.java	
@@ -1,24 +1,16 @@
 class Solution {
   public int[] findingUsersActiveMinutes(int[][] logs, int k) {
     Map<Integer, Set<Integer>> map = new HashMap<>();
-    List<Set<Integer>> setList = new ArrayList<>();
-    for (int i = 0; i < k; i++) {
-      setList.add(new HashSet<>());
-    }
     for (int[] log : logs) {
-      map.computeIfAbsent(log[0], j -> new HashSet<>()).add(log[1]);
-      int currActiveTime = map.get(log[0]).size();
-      if (currActiveTime <= k) {
-        setList.get(currActiveTime - 1).add(log[0]);
-        if (currActiveTime != 1) {
-          setList.get(currActiveTime - 2).remove(log[0]);
-        }
-      }
+      int id = log[0];
+      int minute = log[1];
+      map.computeIfAbsent(id, j -> new HashSet<>()).add(minute);
     }
-    int[] ans = new int[k];
-    for (int i = 0; i < k; i++) {
-      ans[i] = setList.get(i).size();
+    int[] result = new int[k];
+    for (Integer key : map.keySet()) {
+      int uam = map.get(key).size();
+      result[uam - 1]++;
     }
-    return ans;
+    return result;
   }
 }

From a76240abf6fe3e5d8aa9edfd1e0d3cdf64aef551 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 24 Sep 2022 08:20:01 -0700
Subject: [PATCH 1368/2175] Update Path Sum II.java

---
 Medium/Path Sum II.java | 61 +++++++++++++++++++++++++++++++----------
 1 file changed, 46 insertions(+), 15 deletions(-)

diff --git a/Medium/Path Sum II.java b/Medium/Path Sum II.java
index c9610a27..776676f7 100644
--- a/Medium/Path Sum II.java	
+++ b/Medium/Path Sum II.java	
@@ -15,25 +15,56 @@
  */
 class Solution {
   public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
-    List<List<Integer>> list = new ArrayList<>();
-    helper(root, targetSum, new ArrayList<>(), list);
-    return list;
-  }
-  
-  private void helper(TreeNode root, int targetSum, List<Integer> curr, List<List<Integer>> list) {
+    List<List<Integer>> result = new ArrayList<>();
     if (root == null) {
-      return;
+      return result;
     }
-    curr.add(root.val);
-    if (isLeaf(root) && (targetSum - root.val) == 0) {
-      list.add(new ArrayList<>(curr));
+    Queue<NodePathSumWrapper> queue = new LinkedList<>();
+    NodePathSumWrapper currNode = new NodePathSumWrapper(root, 0);
+    currNode.addToPath(root.val);
+    queue.add(currNode);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      while (size-- > 0) {
+        NodePathSumWrapper removed = queue.remove();
+        TreeNode node = removed.node;
+        if (node.left == null && node.right == null) {
+          if (removed.currSum == targetSum) {
+            result.add(new ArrayList<>(removed.path));
+          }
+        } else {
+          if (node.left != null) {
+            NodePathSumWrapper leftNodeWrapper = new NodePathSumWrapper(node.left, removed.currSum);
+            leftNodeWrapper.path.addAll(removed.path);
+            leftNodeWrapper.addToPath(node.left.val);
+            queue.add(leftNodeWrapper);
+          }
+          if (node.right != null) {
+            NodePathSumWrapper rightNodeWrapper = new NodePathSumWrapper(node.right, removed.currSum);
+            rightNodeWrapper.path.addAll(removed.path);
+            rightNodeWrapper.addToPath(node.right.val);
+            queue.add(rightNodeWrapper);
+          }
+        }
+      }
     }
-    helper(root.left, targetSum - root.val, curr, list);
-    helper(root.right, targetSum - root.val, curr, list);
-    curr.remove(curr.size() - 1);
+    return result;
   }
   
-  private boolean isLeaf(TreeNode root) {
-    return root.left == null && root.right == null;
+  private static class NodePathSumWrapper {
+    TreeNode node;
+    int currSum;
+    List<Integer> path;
+    
+    public NodePathSumWrapper(TreeNode node, int currSum) {
+      this.node = node;
+      this.currSum = currSum;
+      this.path = new ArrayList<>();
+    }
+    
+    public void addToPath(int value) {
+      this.path.add(value);
+      this.currSum += value;
+    }
   }
 }

From af2ea2fc678f817ecdf97cb63725ce8091a62fb1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 24 Sep 2022 10:54:29 -0700
Subject: [PATCH 1369/2175] Create Number of Distinct Substrings in a
 String.java

---
 ...er of Distinct Substrings in a String.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Number of Distinct Substrings in a String.java

diff --git a/Medium/Number of Distinct Substrings in a String.java b/Medium/Number of Distinct Substrings in a String.java
new file mode 100644
index 00000000..17d2a053
--- /dev/null
+++ b/Medium/Number of Distinct Substrings in a String.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public int countDistinct(String s) {
+    TrieNode root = new TrieNode();
+    int n = s.length();
+    int count = 0;
+    for (int i = 0; i < n; i++) {
+      TrieNode curr = root;
+      for (int j = i; j < n; j++) {
+        if (!curr.children.containsKey(s.charAt(j))) {
+          count++;
+          curr.children.put(s.charAt(j), new TrieNode());
+        }
+        curr = curr.children.get(s.charAt(j));
+      }
+    }
+    return count;
+  }
+  
+  private static class TrieNode {
+    Map<Character, TrieNode> children;
+    
+    public TrieNode() {
+      this.children = new HashMap<>();
+    }
+  }
+}

From 6f8dbd775a1dda098b532195266d5ad4639e9441 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 24 Sep 2022 12:11:36 -0700
Subject: [PATCH 1370/2175] Update Task Scheduler.java

---
 Medium/Task Scheduler.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Medium/Task Scheduler.java b/Medium/Task Scheduler.java
index 5d535437..558e1f77 100644
--- a/Medium/Task Scheduler.java	
+++ b/Medium/Task Scheduler.java	
@@ -1,14 +1,14 @@
 class Solution {
   public int leastInterval(char[] tasks, int n) {
-    int[] counter = new int[26];
+    int[] frequencies = new int[26];
     for (char task : tasks) {
-      counter[task - 'A']++;
+      frequencies[task - 'A']++;
     }
-    Arrays.sort(counter);
-    int maxFrequency = counter[25];
+    Arrays.sort(frequencies);
+    int maxFrequency = frequencies[25];
     int idleTime = (maxFrequency - 1) * n;
-    for (int i = counter.length - 2; i >= 0 && idleTime > 0; i--) {
-      idleTime -= Math.min(maxFrequency - 1, counter[i]);
+    for (int i = frequencies.length - 2; i >= 0 && idleTime > 0; i--) {
+      idleTime -= Math.min(maxFrequency - 1, frequencies[i]);
     }
     idleTime = Math.max(0, idleTime);
     return idleTime + tasks.length;

From efb31e899f355bd330b829d2743d7b4763b77b61 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Sep 2022 07:26:34 -0700
Subject: [PATCH 1371/2175] Update Design Circular Queue.java

---
 Medium/Design Circular Queue.java | 48 +++++++++++++------------------
 1 file changed, 20 insertions(+), 28 deletions(-)

diff --git a/Medium/Design Circular Queue.java b/Medium/Design Circular Queue.java
index ee595135..d5f90b31 100644
--- a/Medium/Design Circular Queue.java	
+++ b/Medium/Design Circular Queue.java	
@@ -1,60 +1,52 @@
 class MyCircularQueue {
+  
+  private Integer[] queue;
+  private int valueCursor;
+  private int emptyCursor;
 
-  /** Initialize your data structure here. Set the size of the queue to be k. */
-  int[] queue;
-  int start;
-  int end;
-  int k;
   public MyCircularQueue(int k) {
-    this.k = k;
-    queue = new int[k];
-    start = 0;
-    end = 0;
-    Arrays.fill(queue, -1);
+    this.queue = new Integer[k];
+    this.valueCursor = 0;
+    this.emptyCursor = 0;
   }
 
-  /** Insert an element into the circular queue. Return true if the operation is successful. */
   public boolean enQueue(int value) {
-    if (end == start && queue[end] != -1) {
+    if (queue[emptyCursor] != null) {
       return false;
     }
-    queue[end++] = value;
-    if (end == k) {
-      end = 0;
+    queue[emptyCursor++] = value;
+    if (emptyCursor == queue.length) {
+      emptyCursor = 0;
     }
     return true;
   }
 
-  /** Delete an element from the circular queue. Return true if the operation is successful. */
   public boolean deQueue() {
-    if (queue[start] == -1) {
+    if (queue[valueCursor] == null) {
       return false;
     }
-    queue[start++] = -1;
-    if (start == k) {
-      start = 0;
+    queue[valueCursor++] = null;
+    if (valueCursor == queue.length) {
+      valueCursor = 0;
     }
     return true;
   }
 
-  /** Get the front item from the queue. */
   public int Front() {
-    return queue[start];
+    return queue[valueCursor] == null ? -1 : queue[valueCursor];
   }
 
-  /** Get the last item from the queue. */
   public int Rear() {
-    return end == 0 ? queue[k - 1] : queue[end - 1];
+    int idx = emptyCursor == 0 ? queue.length - 1 : emptyCursor - 1;
+    return queue[idx] == null ? -1 : queue[idx];
   }
 
-  /** Checks whether the circular queue is empty or not. */
   public boolean isEmpty() {
-    return start == end && queue[end] == -1;
+    return queue[valueCursor] == null;
   }
 
-  /** Checks whether the circular queue is full or not. */
   public boolean isFull() {
-    return start == end && queue[end] != -1;
+    return queue[emptyCursor] != null;
   }
 }
 

From de8a44021575921b9959309fdd7ebf2cbb0cdf72 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Sep 2022 07:37:54 -0700
Subject: [PATCH 1372/2175] Create Sort the People.java

---
 Easy/Sort the People.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Sort the People.java

diff --git a/Easy/Sort the People.java b/Easy/Sort the People.java
new file mode 100644
index 00000000..03678ec2
--- /dev/null
+++ b/Easy/Sort the People.java	
@@ -0,0 +1,10 @@
+class Solution {
+  public String[] sortPeople(String[] names, int[] heights) {
+    return IntStream.range(0, names.length)
+        .boxed()
+        .sorted((o1, o2) -> heights[o2] - heights[o1])
+        .map(idx -> names[idx])
+        .toList()
+        .toArray(new String[0]);
+  }
+}

From cc332e27ccc493cb1b757625b1b781f344b23709 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Sep 2022 08:28:05 -0700
Subject: [PATCH 1373/2175] Create Sort Integers by The Power Value.java

---
 Medium/Sort Integers by The Power Value.java | 28 ++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Sort Integers by The Power Value.java

diff --git a/Medium/Sort Integers by The Power Value.java b/Medium/Sort Integers by The Power Value.java
new file mode 100644
index 00000000..1ca20e69
--- /dev/null
+++ b/Medium/Sort Integers by The Power Value.java	
@@ -0,0 +1,28 @@
+class Solution {
+  public int getKth(int lo, int hi, int k) {
+    Map<Integer, Integer> cache = new HashMap<>();
+    cache.put(1, 0);
+    PriorityQueue<Integer> pq = new PriorityQueue<>(
+        Comparator.comparingInt((Integer o) -> cache.get(o)).thenComparingInt(o -> o));
+    for (int i = lo; i <= hi; i++) {
+      calculateSteps(cache, i);
+      pq.add(i);
+    }
+    while (!pq.isEmpty() && k-- > 1) {
+      pq.poll();
+    }
+    return pq.peek();
+  }
+
+  private int calculateSteps(Map<Integer, Integer> cache, int num) {
+    if (num == 1) {
+      return 0;
+    }
+    if (cache.containsKey(num)) {
+      return cache.get(num);
+    }
+    int numOfSteps = 1 + calculateSteps(cache, (num % 2 == 0 ? num / 2 : num * 3 + 1));
+    cache.put(num, numOfSteps);
+    return cache.get(num);
+  }
+}

From e2e24c78aa810257b990cae4b227e98a1c31f3cb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Sep 2022 08:31:30 -0700
Subject: [PATCH 1374/2175] Update Sort Integers by The Power Value.java

---
 Medium/Sort Integers by The Power Value.java | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/Medium/Sort Integers by The Power Value.java b/Medium/Sort Integers by The Power Value.java
index 1ca20e69..aa9a5fa6 100644
--- a/Medium/Sort Integers by The Power Value.java	
+++ b/Medium/Sort Integers by The Power Value.java	
@@ -15,9 +15,6 @@ public int getKth(int lo, int hi, int k) {
   }
 
   private int calculateSteps(Map<Integer, Integer> cache, int num) {
-    if (num == 1) {
-      return 0;
-    }
     if (cache.containsKey(num)) {
       return cache.get(num);
     }

From ab63ec58b5e8fbb8d6a5dfaa35cd3ac3150f8244 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Sep 2022 18:33:56 -0700
Subject: [PATCH 1375/2175] Create Satisfiability of Equality Equations.java

---
 .../Satisfiability of Equality Equations.java | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Satisfiability of Equality Equations.java

diff --git a/Medium/Satisfiability of Equality Equations.java b/Medium/Satisfiability of Equality Equations.java
new file mode 100644
index 00000000..cba2bf2a
--- /dev/null
+++ b/Medium/Satisfiability of Equality Equations.java	
@@ -0,0 +1,42 @@
+class Solution {
+  public boolean equationsPossible(String[] equations) {
+    List<Integer>[] graph = new ArrayList[26];
+    for (int i = 0; i < 26; i++) {
+      graph[i] = new ArrayList<>();
+    }
+    for (String equation : equations) {
+      if (equation.charAt(1) == '=') {
+        int first = equation.charAt(0) - 'a';
+        int second = equation.charAt(3) - 'a';
+        graph[first].add(second);
+        graph[second].add(first);
+      }
+    }
+    int[] color = new int[26];
+    Arrays.fill(color, -1);
+    for (int i = 0; i < 26; i++) {
+      if (color[i] == -1) {
+        dfs(i, i, color, graph);
+      }
+    }
+    for (String equation : equations) {
+      if (equation.charAt(1) == '!') {
+        int first = equation.charAt(0) - 'a';
+        int second = equation.charAt(3) - 'a';
+        if (color[first] == color[second]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  
+  private static void dfs(int node, int nodeColor, int[] color, List<Integer>[] graph) {
+    if (color[node] == -1) {
+      color[node] = nodeColor;
+      for (int neighbor : graph[node]) {
+        dfs(neighbor, nodeColor, color, graph);
+      }
+    }
+  }
+}

From 28a49d33c1650bb139648a4f3cdf71d256b243b5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 26 Sep 2022 08:28:15 -0700
Subject: [PATCH 1376/2175] Update Check Whether Two Strings are Almost
 Equivalent.java

---
 ...k Whether Two Strings are Almost Equivalent.java | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/Easy/Check Whether Two Strings are Almost Equivalent.java b/Easy/Check Whether Two Strings are Almost Equivalent.java
index b417eb30..e80ee212 100644
--- a/Easy/Check Whether Two Strings are Almost Equivalent.java	
+++ b/Easy/Check Whether Two Strings are Almost Equivalent.java	
@@ -1,10 +1,15 @@
 class Solution {
   public boolean checkAlmostEquivalent(String word1, String word2) {
-    int[] counter = new int[26];
+    int[] frequency = new int[26];
     for (int i = 0; i < word1.length(); i++) {
-      counter[word1.charAt(i) - 'a']++;
-      counter[word2.charAt(i) - 'a']--;
+      frequency[word1.charAt(i) - 'a']++;
+      frequency[word2.charAt(i) - 'a']--;
     }
-    return IntStream.range(0, 26).allMatch(idx -> Math.abs(counter[idx]) <= 3);
+    for (int i = 0; i < 26; i++) {
+      if (Math.abs(frequency[i]) > 3) {
+        return false;
+      }
+    }
+    return true;
   }
 }

From 2f9945adc8b4bd81430d4043e9e80a2632cfe9b5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 26 Sep 2022 09:09:46 -0700
Subject: [PATCH 1377/2175] Update Check If a Number Is Majority Element in a
 Sorted Array.java

---
 ...Is Majority Element in a Sorted Array.java | 43 +++++++++++++++----
 1 file changed, 34 insertions(+), 9 deletions(-)

diff --git a/Easy/Check If a Number Is Majority Element in a Sorted Array.java b/Easy/Check If a Number Is Majority Element in a Sorted Array.java
index a5620749..5913a03a 100644
--- a/Easy/Check If a Number Is Majority Element in a Sorted Array.java	
+++ b/Easy/Check If a Number Is Majority Element in a Sorted Array.java	
@@ -1,13 +1,38 @@
 class Solution {
-    public boolean isMajorityElement(int[] nums, int target) {
-        if (nums.length == 1) {
-            return nums[0] == target;
-        }
-        
-        if (nums.length == 2) {
-            return nums[0] == target && nums[1] == target;
+  
+  private static enum DIRECTION {
+    LEFT, RIGHT;
+  }
+  
+  public boolean isMajorityElement(int[] nums, int target) {
+    int rightIdx = getIndex(nums, target, DIRECTION.RIGHT);
+    int leftIdx = getIndex(nums, target, DIRECTION.LEFT);
+    if (leftIdx == -1 || rightIdx == -1) {
+      return false;
+    }
+    int occurrences = rightIdx - leftIdx + 1;
+    return occurrences > nums.length / 2;
+  }
+  
+  private int getIndex(int[] nums, int target, DIRECTION direction) {
+    int resultIdx = -1;
+    int left = 0;
+    int right = nums.length - 1;
+    while (left <= right) {
+      int mid = (left + right) / 2;
+      if (nums[mid] == target) {
+        resultIdx = mid;
+        if (direction == DIRECTION.LEFT) {
+          right = mid - 1;
+        } else {
+          left = mid + 1;
         }
-        
-        return nums[nums.length / 2 - 1] == target && nums[nums.length / 2 + 1] == target;
+      } else if (nums[mid] > target) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
     }
+    return resultIdx;
+  }
 }

From 769c6d0a65f6641e0a1752d2d879f04df4669224 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 26 Sep 2022 09:52:52 -0700
Subject: [PATCH 1378/2175] Update Minimum Value to Get Positive Step by Step
 Sum.java

---
 ...nimum Value to Get Positive Step by Step Sum.java | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/Easy/Minimum Value to Get Positive Step by Step Sum.java b/Easy/Minimum Value to Get Positive Step by Step Sum.java
index 0d7401f1..e8b91b93 100644
--- a/Easy/Minimum Value to Get Positive Step by Step Sum.java	
+++ b/Easy/Minimum Value to Get Positive Step by Step Sum.java	
@@ -1,11 +1,15 @@
 class Solution {
   public int minStartValue(int[] nums) {
-    int minPrefixSum = 0;
-    int currSum = 0;
+    int startingValue = 1;
+    int currSum = 1;
     for (int num : nums) {
+      if (currSum + num < 1) {
+        int diff = 1 - (currSum + num);
+        startingValue += diff;
+        currSum += diff;
+      }
       currSum += num;
-      minPrefixSum = Math.min(minPrefixSum, currSum);
     }
-    return -1 * minPrefixSum + 1;
+    return startingValue;
   }
 }

From 02a173e1c2409549fd772f46c9975cc9c4bc4ab7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 26 Sep 2022 10:48:05 -0700
Subject: [PATCH 1379/2175] Update Average Waiting Time.java

---
 Medium/Average Waiting Time.java | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/Medium/Average Waiting Time.java b/Medium/Average Waiting Time.java
index 66d8f464..afba5388 100644
--- a/Medium/Average Waiting Time.java	
+++ b/Medium/Average Waiting Time.java	
@@ -1,13 +1,20 @@
 class Solution {
   public double averageWaitingTime(int[][] customers) {
-    long totalWaitingTime = 0;
-    int currChefTime = 0;
+    double totalWaitingTime = 0.0;
+    int lastFreeTime = 0;
     for (int[] customer : customers) {
-      currChefTime = Math.max(currChefTime, customer[0]);
-      int endTime = currChefTime + customer[1];
-      totalWaitingTime += endTime - customer[0];
-      currChefTime = endTime;
+      int arrivalTime = customer[0];
+      // Wait time before chef finishes previous task
+      if (lastFreeTime > arrivalTime) {
+        totalWaitingTime += lastFreeTime - arrivalTime;
+      } else {
+        lastFreeTime = arrivalTime;
+      }
+      // Wait time to finish task for current customer
+      int taskTime = customer[1];
+      totalWaitingTime += taskTime;
+      lastFreeTime += taskTime;
     }
-    return totalWaitingTime / (double) customers.length;
+    return totalWaitingTime / customers.length;
   }
 }

From e3d529a121ff376392ffb8ebd361e21960e59f5a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 26 Sep 2022 20:25:16 -0700
Subject: [PATCH 1380/2175] Create Push Dominoes.java

---
 Medium/Push Dominoes.java | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Push Dominoes.java

diff --git a/Medium/Push Dominoes.java b/Medium/Push Dominoes.java
new file mode 100644
index 00000000..16753989
--- /dev/null
+++ b/Medium/Push Dominoes.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public String pushDominoes(String dominoes) {
+    int[] forces = new int[dominoes.length()];
+    int force = 0;
+    for (int i = 0; i < dominoes.length(); i++) {
+      if (dominoes.charAt(i) == 'R') {
+        force = dominoes.length();
+      } else if (dominoes.charAt(i) == 'L') {
+        force = 0;
+      } else {
+        force = Math.max(force - 1, 0);
+      }
+      forces[i] += force;
+    }
+    force = 0;
+    for (int i = dominoes.length() - 1; i >= 0; i--) {
+      if (dominoes.charAt(i) == 'L') {
+        force = dominoes.length();
+      } else if (dominoes.charAt(i) == 'R') {
+        force = 0;
+      } else {
+        force = Math.max(force - 1, 0);
+      }
+      forces[i] -= force;
+    }
+    StringBuilder result = new StringBuilder();
+    for (int i = 0; i < forces.length; i++) {
+      result.append(forces[i] > 0 ? 'R' : (forces[i] < 0 ? 'L' : '.'));
+    }
+    return result.toString();
+  }
+}

From 8df0eafdc7b49aca246f16e20cfcda929fa885ec Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 27 Sep 2022 06:38:25 -0700
Subject: [PATCH 1381/2175] Update Number of Distinct Islands.java

---
 Medium/Number of Distinct Islands.java | 49 ++++++++++++--------------
 1 file changed, 23 insertions(+), 26 deletions(-)

diff --git a/Medium/Number of Distinct Islands.java b/Medium/Number of Distinct Islands.java
index d33af963..e9ea1286 100644
--- a/Medium/Number of Distinct Islands.java	
+++ b/Medium/Number of Distinct Islands.java	
@@ -1,38 +1,35 @@
 class Solution {
-  Set<String> set;
-  int[][] dirs = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
   public int numDistinctIslands(int[][] grid) {
-    if (grid.length == 0 || grid[0].length == 0) {
-      return 0;
-    }
-    set = new HashSet<>();
-    boolean[][] visited = new boolean[grid.length][grid[0].length];
-    for (int i = 0; i < grid.length; i++) {
-      for (int j = 0; j < grid[i].length; j++) {
-        if (!visited[i][j]) {
-          StringBuilder sb = new StringBuilder();
-          dfs(grid, i, j, visited, sb, 0);
-          if (sb.length() > 0) {
-            set.add(sb.toString());
-          }
+    int rows = grid.length;
+    int cols = grid[0].length;
+    boolean[][] visited = new boolean[rows][cols];
+    Set<String> islands = new HashSet<>();
+    for (int row = 0; row < rows; row++) {
+      for (int col = 0; col < cols; col++) {
+        StringBuilder currIsland = new StringBuilder();
+        dfs(grid, row, col, visited, currIsland, '0');
+        if (currIsland.length() == 0) {
+          continue;
         }
+        islands.add(currIsland.toString());
       }
     }
-    return set.size();
+    return islands.size();
   }
   
-  private void dfs(int[][] grid, int x, int y, boolean[][] visited, StringBuilder sb, int currDir) {
-    if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] != 1 || visited[x][y]) {
+  private void dfs(int[][] grid, int row, int col, boolean[][] visited, StringBuilder currIsland, char direction) {
+    if (row < 0 || row >= grid.length || col < 0 || col >= grid[0].length) {
       return;
     }
-    sb.append(currDir);
-    visited[x][y] = true;
-    int curr = 1;
-    for (int[] dir : dirs) {
-      int newX = x + dir[0];
-      int newY = y + dir[1];
-      dfs(grid, newX, newY, visited, sb, curr++);
+    if (visited[row][col] || grid[row][col] == 0) {
+      return;
     }
-    sb.append(0);
+    visited[row][col] = true;
+    currIsland.append(direction);
+    dfs(grid, row + 1, col, visited, currIsland, 'D');
+    dfs(grid, row - 1, col, visited, currIsland, 'U');
+    dfs(grid, row, col + 1, visited, currIsland, 'R');
+    dfs(grid, row, col - 1, visited, currIsland, 'L');
+    currIsland.append('0');
   }
 }

From b80526b3fcc2121cc770e09083d6b4e8b44742b7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 27 Sep 2022 06:38:56 -0700
Subject: [PATCH 1382/2175] Create Perfect Rectangle.java

---
 Hard/Perfect Rectangle.java | 41 +++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Hard/Perfect Rectangle.java

diff --git a/Hard/Perfect Rectangle.java b/Hard/Perfect Rectangle.java
new file mode 100644
index 00000000..fb79a5e3
--- /dev/null
+++ b/Hard/Perfect Rectangle.java	
@@ -0,0 +1,41 @@
+class Solution {
+  public boolean isRectangleCover(int[][] rectangles) {
+    int x1 = Integer.MAX_VALUE;
+    int x2 = Integer.MIN_VALUE;
+    int y1 = Integer.MAX_VALUE;
+    int y2 = Integer.MIN_VALUE;
+    Set<String> set = new HashSet<String>();
+    int totalArea = 0;
+    for (int[] rectangle : rectangles) {
+      x1 = Math.min(rectangle[0], x1);
+      y1 = Math.min(rectangle[1], y1);
+      x2 = Math.max(rectangle[2], x2);
+      y2 = Math.max(rectangle[3], y2);
+      totalArea += (rectangle[2] - rectangle[0]) * (rectangle[3] - rectangle[1]);
+      String s1 = rectangle[0] + " " + rectangle[1];
+      String s2 = rectangle[0] + " " + rectangle[3];
+      String s3 = rectangle[2] + " " + rectangle[3];
+      String s4 = rectangle[2] + " " + rectangle[1];
+      if (!set.add(s1)) {
+        set.remove(s1);
+      }
+      if (!set.add(s2)) {
+        set.remove(s2);
+      }
+      if (!set.add(s3)) {
+        set.remove(s3);
+      }
+      if (!set.add(s4)) {
+        set.remove(s4);
+      }
+    }
+    if (!set.contains(x1 + " " + y1) || 
+        !set.contains(x1 + " " + y2) || 
+        !set.contains(x2 + " " + y1) || 
+        !set.contains(x2 + " " + y2) || 
+        set.size() != 4) {
+      return false;
+    }
+    return totalArea == (x2 - x1) * (y2 - y1);
+  }
+}

From 4841f87e74ad093d4b02623b77b68d59598e61b6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 27 Sep 2022 13:46:38 -0700
Subject: [PATCH 1383/2175] Create Minimum Time to Collect All Apples in a
 Tree.java

---
 ... Time to Collect All Apples in a Tree.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Minimum Time to Collect All Apples in a Tree.java

diff --git a/Medium/Minimum Time to Collect All Apples in a Tree.java b/Medium/Minimum Time to Collect All Apples in a Tree.java
new file mode 100644
index 00000000..24feb762
--- /dev/null
+++ b/Medium/Minimum Time to Collect All Apples in a Tree.java	
@@ -0,0 +1,25 @@
+class Solution {
+  public int minTime(int n, int[][] edges, List<Boolean> hasApple) {
+    Map<Integer, Set<Integer>> tree = new HashMap<>();
+    for (int[] edge : edges) {
+      tree.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+      tree.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    }
+    Set<Integer> visited = new HashSet<>();
+    return dfs(0, hasApple, visited, tree);
+  }
+  
+  private int dfs(int node, List<Boolean> hasApple, Set<Integer> visited, Map<Integer, Set<Integer>> tree) {
+    visited.add(node);
+    int result = 0;
+    for (Integer child : tree.getOrDefault(node, new HashSet<>())) {
+      if (!visited.contains(child)) {
+        result += dfs(child, hasApple, visited, tree);
+      }
+    }
+    if ((result > 0 || hasApple.get(node)) && node != 0) {
+      result += 2;
+    }
+    return result;
+  }
+}

From fa57fa7c71da665f8069a858fe64778b02461f4e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 27 Sep 2022 14:46:35 -0700
Subject: [PATCH 1384/2175] Create Max Points on a Line.java

---
 Hard/Max Points on a Line.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Hard/Max Points on a Line.java

diff --git a/Hard/Max Points on a Line.java b/Hard/Max Points on a Line.java
new file mode 100644
index 00000000..7368488e
--- /dev/null
+++ b/Hard/Max Points on a Line.java	
@@ -0,0 +1,26 @@
+class Solution {
+  public int maxPoints(int[][] points) {
+    int max = 0;
+    for (int i = 0; i < points.length - 1; i++) {
+      Map<Double, Integer> map = new HashMap<>();
+      for (int j = i + 1; j < points.length; j++) {
+        double slope = calculateSlope(points[i], points[j]);
+        map.put(slope, map.getOrDefault(slope, 0) + 1);
+        max = Math.max(max, map.get(slope));
+      }
+    }
+    return max + 1;
+  }
+  
+  private double calculateSlope(int[] p1, int[] p2) {
+    double y = (p2[1] - p1[1]) * 1.0;
+    double x = (p2[0] - p1[0]) * 1.0;
+    if (x == 0) {
+      return Double.NaN;
+    }
+    if(y == 0) {
+      return 0.0;
+    }
+    return ((double) y * 1.0) / x;
+  }
+}

From e853f815fc52a6608f2dc1c0cc58d80a01e9f839 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 27 Sep 2022 19:36:54 -0700
Subject: [PATCH 1385/2175] Update Serialize and Deserialize N-ary Tree.java

---
 .../Serialize and Deserialize N-ary Tree.java | 68 +++++++++++--------
 1 file changed, 41 insertions(+), 27 deletions(-)

diff --git a/Hard/Serialize and Deserialize N-ary Tree.java b/Hard/Serialize and Deserialize N-ary Tree.java
index 29d46233..d9df1fa3 100644
--- a/Hard/Serialize and Deserialize N-ary Tree.java	
+++ b/Hard/Serialize and Deserialize N-ary Tree.java	
@@ -16,48 +16,62 @@ public Node(int _val, List<Node> _children) {
     }
 };
 */
+
 class Codec {
-    
   // Encodes a tree to a single string.
-  private final String SEPARATOR = ",";
-  private final String NULL_SEPARATOR = "#";
-  public String serialize(Node root) {
-    StringBuilder sb = new StringBuilder();
-    serializeHelper(root, sb);
-    return sb.toString();
-  }
   
-  private void serializeHelper(Node root, StringBuilder sb) {
+  private static final String SEPARATOR = ",";
+  private static final String NULL_NODE = "X";
+  
+  public String serialize(Node root) {
     if (root == null) {
-      sb.append(NULL_SEPARATOR).append(SEPARATOR);
+      return NULL_NODE;
     }
-    else {
-      sb.append(root.val).append(SEPARATOR).append(root.children.size()).append(SEPARATOR);
-      for (Node child : root.children) {
-        serializeHelper(child, sb);
+    StringBuilder sb = new StringBuilder();
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(root);
+    queue.add(null);
+    while (!queue.isEmpty()) {
+      int size = queue.size();
+      for (int i = 0; i < size; i++) {
+        Node removed = queue.remove();
+        if (removed == null) {
+          sb.append(NULL_NODE).append(SEPARATOR);
+          break;
+        }
+        for (Node child : removed.children) {
+          queue.add(child);
+        }
+        queue.add(null);
+        sb.append(removed.val).append(SEPARATOR);
       }
     }
+    sb.deleteCharAt(sb.length() - 1);
+    return sb.toString();
   }
 
   // Decodes your encoded data to tree.
   public Node deserialize(String data) {
-    Deque<String> dq = new ArrayDeque<>(Arrays.asList(data.split(SEPARATOR)));
-    return deserializeHelper(dq);
-  }
-  
-  private Node deserializeHelper(Deque<String> dq) {
-    String removed = dq.removeFirst();
-    if (removed.equals(NULL_SEPARATOR)) {
+    String[] splits = data.split(SEPARATOR);
+    if (splits[0].equals(NULL_NODE)) {
       return null;
     }
-    else {
-      Node node = new Node(Integer.parseInt(removed), new ArrayList<>());
-      int childCount = Integer.parseInt(dq.removeFirst());
-      for (int i = 0; i < childCount; i++) {
-        node.children.add(deserializeHelper(dq));
+    Node root = new Node(Integer.parseInt(splits[0]));
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(root);
+    int idx = 2;
+    while (idx < splits.length) {
+      Node node = queue.remove();
+      List<Node> children = new ArrayList<>();
+      while (!splits[idx].equals(NULL_NODE)) {
+        Node child = new Node(Integer.parseInt(splits[idx++]));
+        children.add(child);
+        queue.add(child);
       }
-      return node;
+      idx++;
+      node.children = children;
     }
+    return root;
   }
 }
 

From 48560d5ffd3000dc4da87b99a0810326b6e9a438 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 28 Sep 2022 17:19:06 -0700
Subject: [PATCH 1386/2175] Update Find K Closest Elements.java

---
 Medium/Find K Closest Elements.java | 41 ++++++++++++++++++++++++-----
 1 file changed, 34 insertions(+), 7 deletions(-)

diff --git a/Medium/Find K Closest Elements.java b/Medium/Find K Closest Elements.java
index 2e49a608..eeddacba 100644
--- a/Medium/Find K Closest Elements.java	
+++ b/Medium/Find K Closest Elements.java	
@@ -1,11 +1,38 @@
 class Solution {
   public List<Integer> findClosestElements(int[] arr, int k, int x) {
-     return Arrays.stream(arr)
-        .mapToObj(e -> new int[]{e, Math.abs(e - x)})
-        .sorted((o1, o2) -> (o1[1] - o2[1] != 0) ? (o1[1] - o2[1]) : o1[0] - o2[0])
-        .map(e -> e[0])
-        .limit(k)
-        .sorted()
-        .collect(Collectors.toList());
+    List<Integer> result = new ArrayList<>();
+    if (arr.length == k) {
+      for (int num : arr) {
+        result.add(num);
+      }
+      return result;
+    }
+    int left = 0;
+    int right = arr.length;
+    while (left < right) {
+      int mid = (left + right) / 2;
+      if (arr[mid] >= x) {
+        right = mid;
+      } else {
+        left = mid + 1;
+      }
+    }
+    left--;
+    right = left + 1;
+    while (right - left - 1 < k) {
+      if (left == -1) {
+        right++;
+        continue;
+      }
+      if (right == arr.length || Math.abs(arr[left] - x) <= Math.abs(arr[right] - x)) {
+        left--;
+      } else {
+        right++;
+      }
+    }
+    for (int i = left + 1; i < right; i++) {
+      result.add(arr[i]);
+    }
+    return result;
   }
 }

From bbdb48eee960a903b785252257b5b4dfd073e8c8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 29 Sep 2022 15:34:16 -0700
Subject: [PATCH 1387/2175] Create Lexicographical Numbers.java

---
 Medium/Lexicographical Numbers.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Lexicographical Numbers.java

diff --git a/Medium/Lexicographical Numbers.java b/Medium/Lexicographical Numbers.java
new file mode 100644
index 00000000..c0ccab5e
--- /dev/null
+++ b/Medium/Lexicographical Numbers.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public List<Integer> lexicalOrder(int n) {
+    List<Integer> result = new ArrayList<>();
+    for (int i = 1; i < 10; i++) {
+      dfs(i, n, result);
+    }
+    return result;
+  }
+  
+  private void dfs(int curr, int n, List<Integer> result) {
+    if (curr > n) {
+      return;
+    }
+    result.add(curr);
+    for (int i = 0; i < 10; i++) {
+      dfs(10 * curr + i, n, result);
+    }
+  }
+}

From 696f10ba796cd504f68052ca2493a6572c503e1e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 29 Sep 2022 16:48:19 -0700
Subject: [PATCH 1388/2175] Update Shortest Completing Word.java

---
 Easy/Shortest Completing Word.java | 49 +++++++++++++++---------------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/Easy/Shortest Completing Word.java b/Easy/Shortest Completing Word.java
index 1be5e2f8..5e9c9cb3 100644
--- a/Easy/Shortest Completing Word.java	
+++ b/Easy/Shortest Completing Word.java	
@@ -1,33 +1,34 @@
 class Solution {
   public String shortestCompletingWord(String licensePlate, String[] words) {
-    Map<Character, Integer> licenseMap = new HashMap<>();
-    for (Character c : licensePlate.toCharArray()) {
-      if (Character.isLetter(c)) {
-        licenseMap.put(Character.toLowerCase(c), licenseMap.getOrDefault(Character.toLowerCase(c), 0) + 1);
-      }
-    }
-    int minLength = Integer.MAX_VALUE;
-    int minLengthIdx = -1;
+    int shortestWordIdx = -1;
+    Map<Character, Integer> licensePlateFrequency = getFrequencyMap(licensePlate);
     for (int i = 0; i < words.length; i++) {
-      Map<Character, Integer> copyMap = new HashMap<>(licenseMap);
-      boolean found = false;
-      for (Character c : words[i].toCharArray()) {
-        if (copyMap.containsKey(Character.toLowerCase(c))) {
-          copyMap.put(Character.toLowerCase(c), copyMap.get(Character.toLowerCase(c)) - 1);
-          if (copyMap.get(Character.toLowerCase(c)) == 0) {
-            copyMap.remove(Character.toLowerCase(c));
-          }
-        }
-        if (copyMap.size() == 0) {
-          found = true;
-          break;
+      if (canComplete(licensePlateFrequency, words[i])) {
+        if (shortestWordIdx == -1 || words[i].length() < words[shortestWordIdx].length()) {
+          shortestWordIdx = i;
         }
       }
-      if (found && words[i].length() < minLength) {
-        minLength = words[i].length();
-        minLengthIdx = i;
+    }
+    return words[shortestWordIdx];
+  }
+
+  private boolean canComplete(Map<Character, Integer> licensePlateFrequency, String word) {
+    Map<Character, Integer> wordFrequency = getFrequencyMap(word);
+    for (Character key : licensePlateFrequency.keySet()) {
+      if (wordFrequency.getOrDefault(key, 0) < licensePlateFrequency.get(key)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private Map<Character, Integer> getFrequencyMap(String s) {
+    Map<Character, Integer> map = new HashMap<>();
+    for (char c : s.toCharArray()) {
+      if (Character.isLetter(c)) {
+        map.put(Character.toLowerCase(c), map.getOrDefault(Character.toLowerCase(c), 0) + 1);
       }
     }
-    return words[minLengthIdx];
+    return map;
   }
 }

From 236b551467bca57111e7286a4ef44f28b1719b8d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 30 Sep 2022 06:48:44 -0700
Subject: [PATCH 1389/2175] Create The Skyline Problem.java

---
 Hard/The Skyline Problem.java | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Hard/The Skyline Problem.java

diff --git a/Hard/The Skyline Problem.java b/Hard/The Skyline Problem.java
new file mode 100644
index 00000000..92c9e516
--- /dev/null
+++ b/Hard/The Skyline Problem.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public List<List<Integer>> getSkyline(int[][] buildings) {
+    List<List<Integer>> result = new ArrayList<>();
+    List<int[]> heights = new ArrayList<>();
+    for (int[] building : buildings) {
+      heights.add(new int[]{building[0], -1 * building[2]});
+      heights.add(new int[]{building[1], 1 * building[2]});
+    }
+    Collections.sort(heights, (a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
+    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+    pq.add(0);
+    int previousMax = 0;
+    for (int[] height : heights) {
+      if (height[1] < 0) {
+        pq.add(-1 * height[1]);
+      } else {
+        pq.remove(height[1]);
+      }
+      int currentMax = pq.peek();
+      if (currentMax != previousMax) {
+        result.add(Arrays.asList(height[0], currentMax));
+        previousMax = currentMax;
+      }
+    }
+    return result;
+  }
+}

From 8368cad9032a47e77b274f6eb185dcfa11c05428 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 30 Sep 2022 16:32:17 -0700
Subject: [PATCH 1390/2175] Update Check If It Is a Straight Line.java

---
 Easy/Check If It Is a Straight Line.java | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/Easy/Check If It Is a Straight Line.java b/Easy/Check If It Is a Straight Line.java
index 18798145..174053a3 100644
--- a/Easy/Check If It Is a Straight Line.java	
+++ b/Easy/Check If It Is a Straight Line.java	
@@ -1,24 +1,16 @@
 class Solution {
   public boolean checkStraightLine(int[][] coordinates) {
-    if (coordinates.length <= 2) {
-      return true;
-    }
-    int[] p1 = coordinates[0];
-    int[] p2 = coordinates[1];
-    for (int i = 2; i < coordinates.length; i++) {
-      if (!isCollinear(coordinates[i], p1, p2)) {
+    int xOne = coordinates[1][0]; 
+    int yOne = coordinates[1][1];
+    int dx = xOne - coordinates[0][0];
+    int dy = yOne - coordinates[0][1];
+    for (int[] coordinate : coordinates) {
+      int x = coordinate[0];
+      int y = coordinate[1];
+      if (dx * (y - yOne) != dy * (x - xOne)) {
         return false;
       }
     }
     return true;
   }
-  
-  private boolean isCollinear(int[] c, int[] p1, int[] p2) {
-    if (p1[0] == c[0] || p2[0] == c[0]) {
-      return false;
-    }
-    int slope1 = (p1[1] - c[1]) / (p1[0] - c[0]);
-    int slope2 = (p2[1] - c[1]) / (p2[0] - c[0]);
-    return slope1 == slope2;
-  }
 }

From 9d349f127fa17e03a2255cda117d464dc9931603 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 1 Oct 2022 08:41:07 -0700
Subject: [PATCH 1391/2175] Update Decode Ways.java

---
 Medium/Decode Ways.java | 76 +++++++++++++----------------------------
 1 file changed, 23 insertions(+), 53 deletions(-)

diff --git a/Medium/Decode Ways.java b/Medium/Decode Ways.java
index cbba3c77..a959c15a 100644
--- a/Medium/Decode Ways.java	
+++ b/Medium/Decode Ways.java	
@@ -1,58 +1,28 @@
 class Solution {
-    int[] memo;
-    public int numDecodings(String s) {
-        if (s.length() == 0) {
-            return 0;
-        }
-        
-        memo = new int[s.length() + 1];
-        Arrays.fill(memo, -1);
-        
-        return helperDp(0, s);
+  
+  public int numDecodings(String s) {
+    Map<Integer, Integer> map = new HashMap<>();
+    return helper(s, 0, map);
+  } 
+  
+  private int helper(String s, int idx, Map<Integer, Integer> map) {
+    if (map.containsKey(idx)) {
+      return map.get(idx);
     }
-    
-    private int helperDp(int idx, String s) {
-        if (memo[idx] > -1) {
-            return memo[idx];
-        }
-        
-        int n = s.length();
-        if (idx == n) {
-            return memo[idx] = 1;
-        }
-        
-        if (s.charAt(idx) == '0') {
-            return memo[idx] = 0;
-        }
-        
-        int temp = helperRecursive(idx + 1, s);
-        memo[idx + 1] = temp;
-        
-        if (idx < n - 1 && (s.charAt(idx) == '1' || (s.charAt(idx) == '2' && s.charAt(idx + 1) < '7'))) {
-            memo[idx + 2] = helperRecursive(idx + 2, s);
-            temp += memo[idx + 2];
-        }
-        
-        return temp;
+    if (idx == s.length()) {
+      return 1;
     }
-    
-    private int helperRecursive(int idx, String s) {
-        int n = s.length();
-        
-        if (idx == n) {
-            return 1;
-        }
-        
-        if (s.charAt(idx) == '0') {
-            return 0;
-        }
-        
-        int temp = helperRecursive(idx + 1, s);
-        
-        if (idx < n - 1 && (s.charAt(idx) == '1' || (s.charAt(idx) == '2' && s.charAt(idx + 1) < '7'))) {
-            temp += helperRecursive(idx + 2, s);
-        }
-        
-        return temp;
+    if (s.charAt(idx) == '0') {
+      return 0;
     }
+    if (idx == s.length() - 1) {
+      return 1;
+    }
+    int result = helper(s, idx + 1, map);
+    if (Integer.parseInt(s.substring(idx, idx + 2)) <= 26) {
+      result += helper(s, idx + 2, map);
+    }
+    map.put(idx, result);
+    return result;
+  }
 }

From b8ff7834093621c31a36732b1b1c414dbc44120d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 1 Oct 2022 08:59:04 -0700
Subject: [PATCH 1392/2175] Update Minimum Time Difference.java

---
 Medium/Minimum Time Difference.java | 38 ++++++++++++++---------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/Medium/Minimum Time Difference.java b/Medium/Minimum Time Difference.java
index a330bbea..b8ba42a1 100644
--- a/Medium/Minimum Time Difference.java	
+++ b/Medium/Minimum Time Difference.java	
@@ -1,23 +1,21 @@
 class Solution {
-    public int findMinDifference(List<String> timePoints) {
-        int[] mins = new int[timePoints.size()];
-        int i = 0;
-        for (String s : timePoints) {
-            int hr = Integer.parseInt(s.split(":")[0]);
-            int ms = Integer.parseInt(s.split(":")[1]);
-            
-            mins[i] = hr*60 + ms;
-            i++;
-        }
-        
-        Arrays.sort(mins);
-        
-        int minTime = Integer.MAX_VALUE;
-        
-        for(int j=1;j<mins.length;j++) {
-            minTime = Math.min(minTime, mins[j] - mins[j-1]);
-        }
-
-        return Math.min(minTime, mins[0] + 1440 - mins[mins.length-1]);
+  public int findMinDifference(List<String> timePoints) {
+    List<Integer> minutes = new ArrayList<>();
+    for (String timePoint : timePoints) {
+      minutes.add(
+        Integer.parseInt(timePoint.split(":")[0]) * 60 + 
+        Integer.parseInt(timePoint.split(":")[1]));
     }
+    Collections.sort(minutes);
+    int prev = Integer.MIN_VALUE;
+    int minDiff = Integer.MAX_VALUE;
+    for (int minute : minutes) {
+      if (prev != Integer.MIN_VALUE) {
+        minDiff = Math.min(minDiff, minute - prev);
+      }
+      prev = minute;
+    }
+    minDiff = Math.min(minDiff, (24 * 60 - minutes.get(minutes.size() - 1) + minutes.get(0)));
+    return minDiff;
+  }
 }

From d40ee27cfb3eb3a1fdcf29cef25a8bf111e79098 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 1 Oct 2022 11:12:26 -0700
Subject: [PATCH 1393/2175] Create Remove Letter To Equalize Frequency.java

---
 Easy/Remove Letter To Equalize Frequency.java | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Easy/Remove Letter To Equalize Frequency.java

diff --git a/Easy/Remove Letter To Equalize Frequency.java b/Easy/Remove Letter To Equalize Frequency.java
new file mode 100644
index 00000000..05c950c2
--- /dev/null
+++ b/Easy/Remove Letter To Equalize Frequency.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public boolean equalFrequency(String word) {
+    int[] frequency = new int[26];
+    int maxFrequency = 0;
+    for (char c : word.toCharArray()) {
+      frequency[c - 'a']++;
+      maxFrequency = Math.max(maxFrequency, frequency[c - 'a']);
+    }
+    int maxCount = 0;
+    int maxMinusOneCount = 0;
+    for (int i = 0; i < 26; i++) {
+      if (frequency[i] == 0) {
+        continue;
+      }
+      if (frequency[i] == maxFrequency) {
+        maxCount++;
+      }
+      if (frequency[i] == maxFrequency - 1) {
+        maxMinusOneCount++;
+      }
+      if (frequency[i] < maxFrequency - 1) {
+        return false;
+      }
+    }
+    return maxMinusOneCount == 1 || maxCount == 1 || (maxMinusOneCount == 0 && maxFrequency == 1);
+  }
+}

From 78c258d69c19fde8002901d3f12b979e07ba4cac Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 1 Oct 2022 11:29:34 -0700
Subject: [PATCH 1394/2175] Create Longest Uploaded Prefix.java

---
 Medium/Longest Uploaded Prefix.java | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Longest Uploaded Prefix.java

diff --git a/Medium/Longest Uploaded Prefix.java b/Medium/Longest Uploaded Prefix.java
new file mode 100644
index 00000000..f7d3f6f1
--- /dev/null
+++ b/Medium/Longest Uploaded Prefix.java	
@@ -0,0 +1,28 @@
+class LUPrefix {
+
+  private int longestPrefixIndex;
+  private boolean[] uploaded;
+  
+  public LUPrefix(int n) {
+    this.uploaded = new boolean[n];
+    this.longestPrefixIndex = 0;
+  }
+
+  public void upload(int video) {
+    uploaded[video - 1] = true;
+    while (longestPrefixIndex < uploaded.length && uploaded[longestPrefixIndex]) {
+      longestPrefixIndex++;
+    }
+  }
+
+  public int longest() {
+    return longestPrefixIndex;
+  }
+}
+
+/**
+ * Your LUPrefix object will be instantiated and called as such:
+ * LUPrefix obj = new LUPrefix(n);
+ * obj.upload(video);
+ * int param_2 = obj.longest();
+ */

From e620caa766643dc6ef4b2d05a7637bf8c03d8ef5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 2 Oct 2022 06:27:30 -0700
Subject: [PATCH 1395/2175] Create Number of Common Factors.java

---
 Easy/Number of Common Factors.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Number of Common Factors.java

diff --git a/Easy/Number of Common Factors.java b/Easy/Number of Common Factors.java
new file mode 100644
index 00000000..4ecdf04e
--- /dev/null
+++ b/Easy/Number of Common Factors.java	
@@ -0,0 +1,12 @@
+class Solution {
+  public int commonFactors(int a, int b) {
+    int count = 0;
+    int minNum = Math.min(a, b);
+    for (int i = 1; i <= minNum / 2; i++) {
+      if (a % i == 0 && b % i == 0) {
+        count++;
+      }
+    }
+    return count + (a % minNum == 0 && b % minNum == 0 ? 1 : 0);
+  }
+}

From 3bdc3837cf233ccea91024ebf4ca417e759dbc47 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 2 Oct 2022 06:32:59 -0700
Subject: [PATCH 1396/2175] Create Maximum Sum of an Hourglass.java

---
 Medium/Maximum Sum of an Hourglass.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Maximum Sum of an Hourglass.java

diff --git a/Medium/Maximum Sum of an Hourglass.java b/Medium/Maximum Sum of an Hourglass.java
new file mode 100644
index 00000000..c819295a
--- /dev/null
+++ b/Medium/Maximum Sum of an Hourglass.java	
@@ -0,0 +1,22 @@
+class Solution {
+  
+  private static final int[][] coordinates = {{0, 0}, {0, 1}, {0, 2}, {1, 1}, {2, 0}, {2, 1}, {2, 2}}; 
+  
+  public int maxSum(int[][] grid) {
+    int rows = grid.length;
+    int cols = grid[0].length;
+    int highestHourglassSum = 0;
+    for (int i = 0; i < rows - 2; i++) {
+      for (int j = 0; j < cols - 2; j++) {
+        int currSum = 0;
+        for (int[] coordinate : coordinates) {
+          int x = i + coordinate[0];
+          int y = j + coordinate[1];
+          currSum += grid[x][y];
+        }
+        highestHourglassSum = Math.max(highestHourglassSum, currSum);
+      }
+    }
+    return highestHourglassSum;
+  }
+}

From bd54e0b674dddf3c9f5bf370929912a67d49adc6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 2 Oct 2022 18:05:09 -0700
Subject: [PATCH 1397/2175] Create Minimum Time to Make Rope Colorful.java

---
 .../Minimum Time to Make Rope Colorful.java   | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Minimum Time to Make Rope Colorful.java

diff --git a/Medium/Minimum Time to Make Rope Colorful.java b/Medium/Minimum Time to Make Rope Colorful.java
new file mode 100644
index 00000000..97cc34e1
--- /dev/null
+++ b/Medium/Minimum Time to Make Rope Colorful.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int minCost(String colors, int[] neededTime) {
+    int totalTime = 0;
+    int left = 0;
+    int right = 0;
+    while (right < colors.length()) {
+      int currTotal = 0;
+      int currMax = 0;
+      while (left < neededTime.length && colors.charAt(right) == colors.charAt(left)) {
+        currTotal += neededTime[left];
+        currMax = Math.max(currMax, neededTime[left]);
+        left++;
+      }
+      totalTime += currTotal - currMax;
+      right = left;
+    }
+    return totalTime;
+  }
+}

From bfb2be8bdc836d9f9a791680e445017af32c62bd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 5 Oct 2022 06:48:30 -0700
Subject: [PATCH 1398/2175] Update Add One Row to Tree.java

---
 Medium/Add One Row to Tree.java | 66 ++++++++++++++++++---------------
 1 file changed, 37 insertions(+), 29 deletions(-)

diff --git a/Medium/Add One Row to Tree.java b/Medium/Add One Row to Tree.java
index 06a5e253..38075d28 100644
--- a/Medium/Add One Row to Tree.java	
+++ b/Medium/Add One Row to Tree.java	
@@ -4,40 +4,48 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode addOneRow(TreeNode root, int v, int d) {
-        if (d == 1) {
-            TreeNode t = new TreeNode(v);
-            t.left = root;
-            return t;
-        }
-        
-        helper(root, v, d, 1);
-        return root;
+  public TreeNode addOneRow(TreeNode root, int val, int depth) {
+    if (depth == 1) {
+      TreeNode newRoot = new TreeNode(val);
+      newRoot.left = root;
+      return newRoot;
     }
-    
-    private void helper(TreeNode root, int v, int d, int currLevel) {
-        if (currLevel == d-1) {
-            TreeNode t1 = new TreeNode(v);
-            TreeNode t2 = new TreeNode(v);
-            
-            t1.left = root.left;
-            t2.right = root.right;
-            root.left = t1;
-            root.right = t2;
-            
-            return;
-        }
-        
-        if (root.left != null) {
-            helper(root.left, v, d, currLevel + 1);
+    int currDepth = 1;
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (currDepth < depth - 1) {
+      Queue<TreeNode> temp = new LinkedList<>();
+      while (!queue.isEmpty()) {
+        TreeNode removed = queue.remove();
+        if (removed.left != null) {
+          temp.add(removed.left);
         }
-        
-        if (root.right != null) {
-            helper(root.right, v, d, currLevel + 1);
+        if (removed.right != null) {
+          temp.add(removed.right);
         }
+      }
+      queue = temp;
+      currDepth++;
+    }
+    while (!queue.isEmpty()) {
+      TreeNode node = queue.remove();
+      TreeNode temp = node.left;
+      node.left = new TreeNode(val);
+      node.left.left = temp;
+      temp = node.right;
+      node.right = new TreeNode(val);
+      node.right.right = temp;
     }
+    return root;
+  }
 }

From 6f6b8f72fdf887665ebf3705c86e744008b5e16e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 7 Oct 2022 07:12:02 -0700
Subject: [PATCH 1399/2175] Update My Calendar II.java

---
 Medium/My Calendar II.java | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/Medium/My Calendar II.java b/Medium/My Calendar II.java
index 4eb4e177..5553a51c 100644
--- a/Medium/My Calendar II.java	
+++ b/Medium/My Calendar II.java	
@@ -1,18 +1,20 @@
 class MyCalendarTwo {
-  TreeMap<Integer, Integer> map;
+  
+  private TreeMap<Integer, Integer> delta;
+  
   public MyCalendarTwo() {
-    map = new TreeMap<>();
+    this.delta = new TreeMap<>();
   }
 
   public boolean book(int start, int end) {
-    map.put(start, map.getOrDefault(start, 0) + 1);
-    map.put(end, map.getOrDefault(end, 0) - 1);
-    int eventCount = 0;
-    for (int val : map.values()) {
-      eventCount += val;
-      if (eventCount >= 3) {
-        map.put(start, map.get(start) - 1);
-        map.put(end, map.get(end) + 1);
+    delta.put(start, delta.getOrDefault(start, 0) + 1);
+    delta.put(end, delta.getOrDefault(end, 0) - 1);
+    int active = 0;
+    for (int d : delta.values()) {
+      active += d;
+      if (active >= 3) {
+        delta.put(start, delta.get(start) - 1);
+        delta.put(end, delta.get(end) + 1);
         return false;
       }
     }

From dc1504aaec81030c4c2cb03b6c0befd89ffe8a16 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 7 Oct 2022 07:14:45 -0700
Subject: [PATCH 1400/2175] Create My Calendar III.java

---
 Hard/My Calendar III.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Hard/My Calendar III.java

diff --git a/Hard/My Calendar III.java b/Hard/My Calendar III.java
new file mode 100644
index 00000000..47a51702
--- /dev/null
+++ b/Hard/My Calendar III.java	
@@ -0,0 +1,26 @@
+class MyCalendarThree {
+  
+  private TreeMap<Integer, Integer> delta;
+  
+  public MyCalendarThree() {
+    this.delta = new TreeMap<>();
+  }
+
+  public int book(int start, int end) {
+    delta.put(start, delta.getOrDefault(start, 0) + 1);
+    delta.put(end, delta.getOrDefault(end, 0) - 1);
+    int activeEvents = 0;
+    int maxEvents = 0;
+    for (int d : delta.values()) {
+      activeEvents += d;
+      maxEvents = Math.max(maxEvents, activeEvents);
+    }
+    return maxEvents;
+  }
+}
+
+/**
+ * Your MyCalendarThree object will be instantiated and called as such:
+ * MyCalendarThree obj = new MyCalendarThree();
+ * int param_1 = obj.book(start,end);
+ */

From 85b3cd517cdfe88a37db7988202f3199879c641c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 7 Oct 2022 07:59:54 -0700
Subject: [PATCH 1401/2175] Update Game of Life.java

---
 Medium/Game of Life.java | 37 +++++++++++++++++++++++--------------
 1 file changed, 23 insertions(+), 14 deletions(-)

diff --git a/Medium/Game of Life.java b/Medium/Game of Life.java
index b1cc147d..4341ee13 100644
--- a/Medium/Game of Life.java	
+++ b/Medium/Game of Life.java	
@@ -1,39 +1,48 @@
 class Solution {
-  int[][] dirs = {{1, 0}, {0, 1}, {1, 1}, {-1, -1}, {-1, 0}, {0, -1}, {1, -1}, {-1, 1}};
+  
+  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
+
   public void gameOfLife(int[][] board) {
     int rows = board.length;
     int cols = board[0].length;
     for (int i = 0; i < rows; i++) {
       for (int j = 0; j < cols; j++) {
-        int count = getLiveNeighbourCount(board, i, j);
+        int liveNeighborCount = getLiveNeighbours(board, i, j);
         if (board[i][j] == 1) {
-          if (count < 2 || count > 3) {
-            board[i][j] = -1;
-          }
-        }
-        else {
-          if (count == 3) {
+          if (liveNeighborCount < 2 || liveNeighborCount > 3) {
             board[i][j] = 2;
           }
+        } else {
+          if (liveNeighborCount == 3) {
+            board[i][j] = 3;
+          }
         }
       }
     }
     for (int i = 0; i < rows; i++) {
       for (int j = 0; j < cols; j++) {
-        board[i][j] = board[i][j] > 0 ? 1 : 0;
+        if (board[i][j] == 2) {
+          board[i][j] = 0;
+        } else if (board[i][j] == 3) {
+          board[i][j] = 1;
+        }
       }
     }
   }
   
-  private int getLiveNeighbourCount(int[][] board, int x, int y) {
+  private static int getLiveNeighbours(int[][] board, int i, int j) {
     int count = 0;
-    for (int[] dir : dirs) {
-      int newX = x + dir[0];
-      int newY = y + dir[1];
-      if (newX >= 0 && newX < board.length && newY >= 0 && newY < board[0].length && Math.abs(board[newX][newY]) == 1) {
+    for (int[] dir : DIRS) {
+      int x = i + dir[0];
+      int y = j + dir[1];
+      if (isValidCell(board, x, y) && (board[x][y] == 1 || board[x][y] == 2)) {
         count++;
       }
     }
     return count;
   }
+  
+  private static boolean isValidCell(int[][] board, int i, int j) {
+    return i >= 0 && j >= 0 && i < board.length && j < board[0].length;
+  }
 }

From 5f0156f2c6d34365721385a850f6cc54265476b0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 7 Oct 2022 12:57:26 -0700
Subject: [PATCH 1402/2175] Update Maximum Number of Occurrences of a
 Substring.java

---
 ... Number of Occurrences of a Substring.java | 41 ++++++++-----------
 1 file changed, 17 insertions(+), 24 deletions(-)

diff --git a/Medium/Maximum Number of Occurrences of a Substring.java b/Medium/Maximum Number of Occurrences of a Substring.java
index 6d957c4f..f0f56202 100644
--- a/Medium/Maximum Number of Occurrences of a Substring.java	
+++ b/Medium/Maximum Number of Occurrences of a Substring.java	
@@ -1,31 +1,24 @@
 class Solution {
   public int maxFreq(String s, int maxLetters, int minSize, int maxSize) {
-    int n = s.length();
-    if (minSize > n) {
-      return 0;
-    }
-    Map<String, Integer> substringMap = new HashMap<>();
-    for (int i = 0; i < n; i++) {
-      Map<Character, Integer> charMap = new HashMap<>();
-      for (int j = 0; j < maxSize; j++) {
-        if (i + j >= n) {
-          break;
-        }       
-        charMap.put(s.charAt(i + j), charMap.getOrDefault(s.charAt(i + j), 0) + 1);
-        if (charMap.size() > maxLetters) {
-          break;
-        }
-        if (j >= minSize - 1) {
-          substringMap.put(
-            s.substring(i, i + j + 1), substringMap.getOrDefault(s.substring(i, i + j + 1), 0) + 1
-          );
+    Map<Character, Integer> letterFrequencyMap = new HashMap<>();
+    Map<String, Integer> substringFrequencyMap = new HashMap<>();
+    int start = 0;
+    int maxCount = 0;
+    for (int i = 0; i < s.length(); i++) {
+      letterFrequencyMap.put(s.charAt(i), letterFrequencyMap.getOrDefault(s.charAt(i), 0) + 1);
+      while (i - start + 1 > minSize || letterFrequencyMap.size() > maxLetters) {
+        letterFrequencyMap.put(s.charAt(start), letterFrequencyMap.getOrDefault(s.charAt(start), 0) - 1);
+        if (letterFrequencyMap.get(s.charAt(start)) == 0) {
+          letterFrequencyMap.remove(s.charAt(start));
         }
+        start++;
+      }
+      if (i - start + 1 == minSize) {
+        String currSubstring = s.substring(start, i + 1);
+        substringFrequencyMap.put(currSubstring, substringFrequencyMap.getOrDefault(currSubstring, 0) + 1);
+        maxCount = Math.max(maxCount, substringFrequencyMap.get(currSubstring));
       }
     }
-    int maxFreqCount = 0;
-    for (String substr : substringMap.keySet()) {
-      maxFreqCount = Math.max(maxFreqCount, substringMap.get(substr));
-    }
-    return maxFreqCount;
+    return maxCount;
   }
 }

From 046236417c41462d88d1f3d69476a10a15c05668 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 8 Oct 2022 10:14:32 -0700
Subject: [PATCH 1403/2175] Update All Possible Full Binary Trees.java

---
 Medium/All Possible Full Binary Trees.java | 62 +++++++++++-----------
 1 file changed, 32 insertions(+), 30 deletions(-)

diff --git a/Medium/All Possible Full Binary Trees.java b/Medium/All Possible Full Binary Trees.java
index 7c7853c4..868b8271 100644
--- a/Medium/All Possible Full Binary Trees.java	
+++ b/Medium/All Possible Full Binary Trees.java	
@@ -4,40 +4,42 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public List<TreeNode> allPossibleFBT(int N) {
-        List<TreeNode> ans = new LinkedList<>();
-        if (N % 2 == 0) {
-            return ans;
-        }
-        
-        return helper(N);
+  public List<TreeNode> allPossibleFBT(int n) {
+    Map<Integer, List<TreeNode>> dp = new HashMap<>();
+    return allPossibleFBTHelper(n, dp);
+  }
+  
+  private List<TreeNode> allPossibleFBTHelper(int n, Map<Integer, List<TreeNode>> dp) {
+    if (dp.containsKey(n)) {
+      return dp.get(n);
     }
-    
-    private List<TreeNode> helper(int N) {
-        List<TreeNode> ans = new LinkedList<>();
-        if (N == 1) {
-            ans.add(new TreeNode(0));
-            return ans;
-        }
-        
-        for (int i = 1; i <= N - 2; i += 2) {
-            List<TreeNode> left = helper(i);
-            List<TreeNode> right = helper(N - i - 1);
-            
-            for (TreeNode leftNode : left) {
-                for (TreeNode rightNode : right) {
-                    TreeNode node = new TreeNode(0);
-                    node.left = leftNode;
-                    node.right = rightNode;
-                    ans.add(node);
-                }
-            }
+    List<TreeNode> result = new ArrayList<>();
+    if (n == 1) {
+      result.add(new TreeNode(0));
+    } else if (n % 2 == 1) {
+      for (int i = 0; i < n; i++) {
+        int j = n - 1 - i;
+        for (TreeNode left : allPossibleFBTHelper(i, dp)) {
+          for (TreeNode right : allPossibleFBTHelper(j, dp)) {
+            TreeNode root = new TreeNode(0);
+            root.left = left;
+            root.right = right;
+            result.add(root);
+          }
         }
-        
-        return ans;
+      }
     }
+    dp.put(n, result);
+    return dp.get(n);
+  }
 }

From 7eb7104196a33fd04a35cae9335c495d92a4f104 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Oct 2022 06:48:44 -0700
Subject: [PATCH 1404/2175] Update Two Sum IV - Input is a BST.java

---
 Easy/Two Sum IV - Input is a BST.java | 31 +++++++++++++++++++--------
 1 file changed, 22 insertions(+), 9 deletions(-)

diff --git a/Easy/Two Sum IV - Input is a BST.java b/Easy/Two Sum IV - Input is a BST.java
index 5f38ca2a..c55e4b47 100644
--- a/Easy/Two Sum IV - Input is a BST.java	
+++ b/Easy/Two Sum IV - Input is a BST.java	
@@ -15,18 +15,31 @@
  */
 class Solution {
   public boolean findTarget(TreeNode root, int k) {
-    Set<Integer> set = new HashSet<>();
-    return helper(root, k, set);
-  }
-  
-  private boolean helper(TreeNode root, int k, Set<Integer> set) {
     if (root == null) {
       return false;
     }
-    if (set.contains(k - root.val)) {
-      return true;
+    Stack<TreeNode> stack = new Stack<>();
+    Set<Integer> set = new HashSet<>();
+    while (root != null) {
+      if (set.contains(k - root.val)) {
+        return true;
+      }
+      stack.push(root);
+      set.add(root.val);
+      root = root.left;
+    }
+    while (!stack.isEmpty()) {
+      TreeNode removed = stack.pop();
+      TreeNode rightNode = removed.right;
+      while (rightNode != null) {
+        if (set.contains(k - rightNode.val)) {
+          return true;
+        }
+        stack.push(rightNode);
+        set.add(rightNode.val);
+        rightNode = rightNode.left;
+      }
     }
-    set.add(root.val);
-    return helper(root.left, k, set) || helper(root.right, k, set);
+    return false;
   }
 }

From d3a44869b06f84365f472ba1bb3bc35c71c51b28 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Oct 2022 06:55:04 -0700
Subject: [PATCH 1405/2175] Create The Employee That Worked on the Longest
 Task.java

---
 ...loyee That Worked on the Longest Task.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/The Employee That Worked on the Longest Task.java

diff --git a/Easy/The Employee That Worked on the Longest Task.java b/Easy/The Employee That Worked on the Longest Task.java
new file mode 100644
index 00000000..e4d30e69
--- /dev/null
+++ b/Easy/The Employee That Worked on the Longest Task.java	
@@ -0,0 +1,20 @@
+class Solution {
+  public int hardestWorker(int n, int[][] logs) {
+    int maxTime = 0;
+    int startTime = 0;
+    int hardestWorkerId = 0;
+    for (int[] log : logs) {
+      int taskTime = log[1] - startTime;
+      startTime = log[1];
+      if (taskTime > maxTime) {
+        maxTime = taskTime;
+        hardestWorkerId = log[0];
+      } else if (taskTime == maxTime) {
+        if (hardestWorkerId > log[0]) {
+          hardestWorkerId = log[0];
+        }
+      }
+    }
+    return hardestWorkerId;
+  }
+}

From 95da6a203854bcd5e958fabea7da63b088504db5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Oct 2022 06:58:02 -0700
Subject: [PATCH 1406/2175] Create Find The Original Array of Prefix Xor.java

---
 Medium/Find The Original Array of Prefix Xor.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Find The Original Array of Prefix Xor.java

diff --git a/Medium/Find The Original Array of Prefix Xor.java b/Medium/Find The Original Array of Prefix Xor.java
new file mode 100644
index 00000000..97baa6e7
--- /dev/null
+++ b/Medium/Find The Original Array of Prefix Xor.java	
@@ -0,0 +1,11 @@
+class Solution {
+  public int[] findArray(int[] pref) {
+    int n = pref.length;
+    int[] result = new int[n];
+    result[0] = pref[0];
+    for (int i = 1; i < n; i++) {
+      result[i] = pref[i] ^ pref[i - 1];
+    }
+    return result;
+  }
+}

From b66408c6a6e30817a01eb9b4d51efcdb5c6ce6aa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Oct 2022 09:49:11 -0700
Subject: [PATCH 1407/2175] Update Building H2O.java

---
 Concurrency/Building H2O.java | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Concurrency/Building H2O.java b/Concurrency/Building H2O.java
index 4d2a6a84..2d2dee57 100644
--- a/Concurrency/Building H2O.java	
+++ b/Concurrency/Building H2O.java	
@@ -1,26 +1,26 @@
 class H2O {
-  private Semaphore hydrogen;
-  private Semaphore oxygen;
-  private Semaphore mutex;
+  
+  private final Semaphore hydrogenSemaphore;
+  private final Semaphore oxygenSemaphore;
 
   public H2O() {
-    this.hydrogen = new Semaphore(2);
-    this.oxygen = new Semaphore(0);
-    this.mutex = new Semaphore(1);
+    this.hydrogenSemaphore = new Semaphore(2);
+    this.oxygenSemaphore = new Semaphore(0);
   }
 
   public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+
+    this.hydrogenSemaphore.acquire();
     // releaseHydrogen.run() outputs "H". Do not change or remove this line.
-    this.hydrogen.acquire();
     releaseHydrogen.run();
-    this.oxygen.release();
+    this.oxygenSemaphore.release();
   }
 
   public void oxygen(Runnable releaseOxygen) throws InterruptedException {
-    this.mutex.acquire();
-    this.oxygen.acquire(2);
+
+    this.oxygenSemaphore.acquire(2);
+    // releaseOxygen.run() outputs "O". Do not change or remove this line.
     releaseOxygen.run();
-    this.hydrogen.release(2);
-    this.mutex.release();
+    this.hydrogenSemaphore.release(2);
   }
 }

From 082e2bf1bd52a719451d2b80edf7675100e53e45 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Oct 2022 17:11:30 -0700
Subject: [PATCH 1408/2175] Update Break a Palindrome.java

---
 Medium/Break a Palindrome.java | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/Medium/Break a Palindrome.java b/Medium/Break a Palindrome.java
index aa82cbe7..3da29e2e 100644
--- a/Medium/Break a Palindrome.java	
+++ b/Medium/Break a Palindrome.java	
@@ -1,13 +1,14 @@
 class Solution {
   public String breakPalindrome(String palindrome) {
-    char[] chars = palindrome.toCharArray();
-    for (int i = 0; i < palindrome.length() / 2; i++) {
-      if (chars[i] > 'a') {
-        chars[i] = 'a';
-        return String.valueOf(chars);
+    if (palindrome.length() == 1) {
+      return "";
+    }
+    for (int i = 0; i < palindrome.length(); i++) {
+      if (palindrome.charAt(i) != 'a' && 
+          (palindrome.length() % 2 == 0 || i != palindrome.length() / 2)) {
+        return palindrome.substring(0, i) + "a" + palindrome.substring(i + 1);
       }
     }
-    chars[chars.length - 1] = 'b';
-    return chars.length <= 1 ? "" : String.valueOf(chars);
+    return palindrome.substring(0, palindrome.length() - 1) + "b";
   }
 }

From d9a8774769d44280e0c179ce128a5eb5058547ed Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 10 Oct 2022 08:00:25 -0700
Subject: [PATCH 1409/2175] Update Delete Node in a BST.java

---
 Medium/Delete Node in a BST.java | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/Medium/Delete Node in a BST.java b/Medium/Delete Node in a BST.java
index 4f9cb6eb..becc3b24 100644
--- a/Medium/Delete Node in a BST.java	
+++ b/Medium/Delete Node in a BST.java	
@@ -18,22 +18,20 @@ public TreeNode deleteNode(TreeNode root, int key) {
     if (root == null) {
       return null;
     }
-    if (root.val > key) {
-      root.left = deleteNode(root.left, key);
-    } else if (root.val < key) {
+    if (key > root.val) {
       root.right = deleteNode(root.right, key);
+    } else if (key < root.val) {
+      root.left = deleteNode(root.left, key);
     } else {
       if (root.left == null || root.right == null) {
-        TreeNode temp = root.left == null ? root.right : root.left;
-        return temp;
-      } else {
-        TreeNode inorderSuccessor = root.right;
-        while (inorderSuccessor.left != null) {
-          inorderSuccessor = inorderSuccessor.left;
-        }
-        root.val = inorderSuccessor.val;
-        root.right = deleteNode(root.right, inorderSuccessor.val);
+        return root.left == null ? root.right : root.left;
+      } 
+      TreeNode inorderSuccessor = root.right;
+      while (inorderSuccessor.left != null) {
+        inorderSuccessor = inorderSuccessor.left;
       }
+      root.val = inorderSuccessor.val;
+      root.right = deleteNode(root.right, inorderSuccessor.val);
     }
     return root;
   }

From 4c1d0136d73cb891a03170827bd91ff1c97e8e12 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 10 Oct 2022 15:51:11 -0700
Subject: [PATCH 1410/2175] Create Design Snake Game.java

---
 Medium/Design Snake Game.java | 91 +++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100644 Medium/Design Snake Game.java

diff --git a/Medium/Design Snake Game.java b/Medium/Design Snake Game.java
new file mode 100644
index 00000000..e4185474
--- /dev/null
+++ b/Medium/Design Snake Game.java	
@@ -0,0 +1,91 @@
+class SnakeGame {
+  
+  private final int width;
+  private final int height;
+  private final Set<Pair<Integer, Integer>> body;
+  private final Deque<Pair<Integer, Integer>> bodyQueue;
+  private final Queue<Pair<Integer, Integer>> foodQueue;
+  private int foodPoint;
+
+  public SnakeGame(int width, int height, int[][] food) {
+    this.width = width;
+    this.height = height;
+    this.body = new HashSet<>();
+    this.bodyQueue = new LinkedList<>();
+    this.body.add(new Pair<Integer, Integer>(0, 0));
+    this.bodyQueue.add(new Pair<Integer, Integer>(0, 0));
+    
+    this.foodQueue = new LinkedList<>();
+    for (int[] fd : food) {
+      foodQueue.add(new Pair<Integer, Integer>(fd[0], fd[1]));
+    }
+    this.foodPoint = 0;
+  }
+
+  public int move(String direction) {
+    Pair<Integer, Integer> currPosition = bodyQueue.peekLast();
+    Pair<Integer, Integer> nextPosition = move(currPosition, direction);
+    if (!isSnakeAlive(nextPosition)) {
+      return -1;
+    }
+    if (!snakeAteFood(nextPosition)) {
+      body.remove(bodyQueue.pollFirst());
+      bodyQueue.addLast(nextPosition);
+      body.add(nextPosition);
+    }
+    return foodPoint;
+  }
+  
+  private Pair<Integer, Integer> move(Pair<Integer, Integer> currPosition, String direction) {
+    int row = currPosition.getKey();
+    int col = currPosition.getValue();
+    switch (direction) {
+      case "U":
+        row--;
+        break;
+      case "D":
+        row++;
+        break;
+      case "L":
+        col--;
+        break;
+      case "R":
+        col++;
+        break;
+      default:
+        break;
+    }
+    return new Pair<Integer, Integer>(row, col);
+  }
+  
+  private boolean isSnakeAlive(Pair<Integer, Integer> position) {
+    int row = position.getKey();
+    int col = position.getValue();
+    // Snake touched the boundary
+    if (!(row >= 0 && col >= 0 && row < height && col < width)) {
+      return false;
+    }
+    // Snake bit somewhere in middle of the body
+    if (!position.equals(this.bodyQueue.peekFirst()) && this.body.contains(position)) {
+      return false;
+    }
+    return true;
+  }
+  
+  private boolean snakeAteFood(Pair<Integer, Integer> position) {
+    if (!foodQueue.isEmpty() && position.equals(foodQueue.peek())) {
+      bodyQueue.addLast(position);
+      body.add(position);
+      foodQueue.poll();
+      foodPoint++;
+      return true;
+    }
+    return false;
+  }
+}
+
+/**
+ * Your SnakeGame object will be instantiated and called as such:
+ * SnakeGame obj = new SnakeGame(width, height, food);
+ * int param_1 = obj.move(direction);
+ */

From 32d86ffd0a143146f80c611c65d083c2005be503 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 10 Oct 2022 18:55:29 -0700
Subject: [PATCH 1411/2175] Update Increasing Triplet Subsequence.java

---
 Medium/Increasing Triplet Subsequence.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/Medium/Increasing Triplet Subsequence.java b/Medium/Increasing Triplet Subsequence.java
index 53e09710..9facec89 100644
--- a/Medium/Increasing Triplet Subsequence.java	
+++ b/Medium/Increasing Triplet Subsequence.java	
@@ -5,11 +5,9 @@ public boolean increasingTriplet(int[] nums) {
     for (int num : nums) {
       if (num <= firstNum) {
         firstNum = num;
-      }
-      else if (num <= secondNum) {
+      } else if (num <= secondNum) {
         secondNum = num;
-      }
-      else {
+      } else {
         return true;
       }
     }

From 06947197969996aecc0998205b20c5ab75854e5f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 11 Oct 2022 14:30:38 -0700
Subject: [PATCH 1412/2175] Update Check if One String Swap Can Make Strings
 Equal.java

---
 ...ne String Swap Can Make Strings Equal.java | 20 +++++++------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/Easy/Check if One String Swap Can Make Strings Equal.java b/Easy/Check if One String Swap Can Make Strings Equal.java
index 6b12d855..3f26dac9 100644
--- a/Easy/Check if One String Swap Can Make Strings Equal.java	
+++ b/Easy/Check if One String Swap Can Make Strings Equal.java	
@@ -1,22 +1,16 @@
 class Solution {
-  public final int UNSET_INDEX = -1;
-  public final int SET_INDEX = 101;
   public boolean areAlmostEqual(String s1, String s2) {
-    int swapIndex = UNSET_INDEX;
+    int mismatchIdx = -1;
     for (int i = 0; i < s1.length(); i++) {
       if (s1.charAt(i) != s2.charAt(i)) {
-        if (swapIndex == SET_INDEX) {
-          return false;
-        } else if (swapIndex == UNSET_INDEX) {
-          swapIndex = i;
-        } else {
-          if (!(s1.charAt(swapIndex) == s2.charAt(i) && s1.charAt(i) == s2.charAt(swapIndex))) {
-            return false;
-          }
-          swapIndex = SET_INDEX;
+        if (mismatchIdx != -1) {
+          return s1.charAt(mismatchIdx) == s2.charAt(i) && 
+            s1.charAt(i) == s2.charAt(mismatchIdx) && 
+            s1.substring(i + 1).equals(s2.substring(i + 1));
         }
+        mismatchIdx = i;
       }
     }
-    return swapIndex == UNSET_INDEX || swapIndex == SET_INDEX;
+    return mismatchIdx == -1;
   }
 }

From 75736cbaef831244dbc186c66a4c2c829bb13929 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Oct 2022 05:58:45 -0700
Subject: [PATCH 1413/2175] Update Largest Perimeter Triangle.java

---
 Easy/Largest Perimeter Triangle.java | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/Easy/Largest Perimeter Triangle.java b/Easy/Largest Perimeter Triangle.java
index bc9803f5..c298121d 100644
--- a/Easy/Largest Perimeter Triangle.java	
+++ b/Easy/Largest Perimeter Triangle.java	
@@ -1,14 +1,11 @@
 class Solution {
-    public int largestPerimeter(int[] A) {
-        Arrays.sort(A);
-        int n = A.length;
-        
-        for (int i=n-1; i>1; i--) {
-            if (A[i] < A[i - 1] + A[i - 2]) {
-                return A[i] + A[i - 1] + A[i - 2];
-            }
-        }
-        
-        return 0;
+  public int largestPerimeter(int[] nums) {
+    Arrays.sort(nums);
+    for (int i = nums.length - 3; i >= 0; i--) {
+      if (nums[i] + nums[i + 1] > nums[i + 2]) {
+        return nums[i] + nums[i + 1] + nums[i + 2];
+      }
     }
+    return 0;
+  }
 }

From c2b9fc5c85bd783bd45c04b5f329c4e5f933223f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Oct 2022 06:37:12 -0700
Subject: [PATCH 1414/2175] Update Minimum Path Sum.java

---
 Medium/Minimum Path Sum.java | 32 ++++++++++++++------------------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/Medium/Minimum Path Sum.java b/Medium/Minimum Path Sum.java
index 5a19e3ac..2100ec3a 100644
--- a/Medium/Minimum Path Sum.java	
+++ b/Medium/Minimum Path Sum.java	
@@ -1,22 +1,18 @@
 class Solution {
-    public static int minPathSum(int[][] grid) {
-        int m = grid.length;
-        int n = grid[0].length;
-
-        for (int i=0; i<m; i++) {
-            for (int j=0; j<n; j++) {
-                if (i == 0 && j != 0) {
-                    grid[i][j] += grid[i][j-1];
-                }
-                if (i != 0 && j == 0) {
-                    grid[i][j] += grid[i-1][j];
-                }
-                if (i != 0 && j != 0) {
-                    grid[i][j] += Math.min(grid[i-1][j], grid[i][j-1]);
-                }
-            }
+  public int minPathSum(int[][] grid) {
+    int[][] dp = new int[grid.length][grid[0].length];
+    for (int i = 0; i < dp.length; i++) {
+      for (int j = 0; j < dp[i].length; j++) {
+        dp[i][j] += grid[i][j];
+        if (i > 0 && j > 0) {
+          dp[i][j] += Math.min(dp[i - 1][j], dp[i][j - 1]);
+        } else if (i > 0) {
+          dp[i][j] += dp[i - 1][j];
+        } else if (j > 0) {
+          dp[i][j] += dp[i][j - 1];
         }
-
-        return grid[m-1][n-1];
+      }
     }
+    return dp[grid.length - 1][grid[0].length - 1];
+  }
 }

From 814554b1fb135cb260bf3e19610ce0f2e966bc47 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Oct 2022 07:25:51 -0700
Subject: [PATCH 1415/2175] Update Design Circular Deque.java

---
 Medium/Design Circular Deque.java | 121 +++++++++++++++++++++---------
 1 file changed, 87 insertions(+), 34 deletions(-)

diff --git a/Medium/Design Circular Deque.java b/Medium/Design Circular Deque.java
index 56c261e5..86949d4a 100644
--- a/Medium/Design Circular Deque.java	
+++ b/Medium/Design Circular Deque.java	
@@ -1,62 +1,115 @@
-class MyCircularQueue {
-  private int[] queue;
-  private int valueCursor;
-  private int emptyCursor;
+class MyCircularDeque {
+  
+  private Node head;
+  private Node tail;
+  private int k;
+  private int currSize;
 
-  public MyCircularQueue(int k) {
-    this.queue = new int[k];
-    Arrays.fill(queue, -1);
-    this.emptyCursor = 0;
-    this.valueCursor = 0;
+  public MyCircularDeque(int k) {
+    this.k = k;
+    this.currSize = 0;
+    this.head = new Node(-1);
+    this.tail = new Node(-1);
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
   }
 
-  public boolean enQueue(int value) {
-    if (this.queue[this.emptyCursor] != -1) {
+  public boolean insertFront(int value) {
+    if (isFull()) {
       return false;
     }
-    this.queue[this.emptyCursor++] = value;
-    if (this.emptyCursor == this.queue.length) {
-      this.emptyCursor = 0;
+    Node node = new Node(value);
+    Node nextToHead = head.next;
+    head.next = node;
+    node.prev = head;
+    node.next = nextToHead;
+    nextToHead.prev = node;
+    currSize++;
+    return true;
+  }
+
+  public boolean insertLast(int value) {
+    if (isFull()) {
+      return false;
     }
+    Node node = new Node(value);
+    Node prevToTail = tail.prev;
+    tail.prev = node;
+    node.next = tail;
+    prevToTail.next = node;
+    node.prev = prevToTail;
+    currSize++;
     return true;
   }
 
-  public boolean deQueue() {
-    if (this.queue[this.valueCursor] == -1) {
+  public boolean deleteFront() {
+    if (isEmpty()) {
       return false;
     }
-    this.queue[this.valueCursor++] = -1;
-    if (this.valueCursor == this.queue.length) {
-      this.valueCursor = 0;
+    Node toDelete = head.next;
+    deleteNode(toDelete);
+    return true;
+  }
+
+  public boolean deleteLast() {
+    if (isEmpty()) {
+      return false;
     }
+    Node toDelete = tail.prev;
+    deleteNode(toDelete);
     return true;
   }
 
-  public int Front() {
-    return this.queue[this.valueCursor];
+  public int getFront() {
+    if (isEmpty()) {
+      return -1;
+    }
+    return head.next.val;
   }
 
-  public int Rear() {
-    int idx = this.emptyCursor == 0 ? this.queue.length - 1 : this.emptyCursor - 1;
-    return this.queue[idx];
+  public int getRear() {
+    if (isEmpty()) {
+      return -1;
+    }
+    return tail.prev.val;
   }
 
   public boolean isEmpty() {
-    return this.queue[this.valueCursor] == -1;
+    return currSize == 0;
   }
 
   public boolean isFull() {
-    return this.queue[this.emptyCursor] != -1;
+    return currSize == k;
+  }
+  
+  private void deleteNode(Node node) {
+    Node prevToNode = node.prev;
+    Node nextToNode = node.next;
+    prevToNode.next = nextToNode;
+    nextToNode.prev = prevToNode;
+    currSize--;
+  }
+  
+  private static class Node {
+    int val;
+    Node next;
+    Node prev;
+    
+    public Node(int val) {
+      this.val = val;
+    }
   }
 }
 
 /**
- * Your MyCircularQueue object will be instantiated and called as such:
- * MyCircularQueue obj = new MyCircularQueue(k);
- * boolean param_1 = obj.enQueue(value);
- * boolean param_2 = obj.deQueue();
- * int param_3 = obj.Front();
- * int param_4 = obj.Rear();
- * boolean param_5 = obj.isEmpty();
- * boolean param_6 = obj.isFull();
+ * Your MyCircularDeque object will be instantiated and called as such:
+ * MyCircularDeque obj = new MyCircularDeque(k);
+ * boolean param_1 = obj.insertFront(value);
+ * boolean param_2 = obj.insertLast(value);
+ * boolean param_3 = obj.deleteFront();
+ * boolean param_4 = obj.deleteLast();
+ * int param_5 = obj.getFront();
+ * int param_6 = obj.getRear();
+ * boolean param_7 = obj.isEmpty();
+ * boolean param_8 = obj.isFull();
  */

From 6af276e0e2045bf3afb81498dfb4844f749ac18c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Oct 2022 13:51:14 -0700
Subject: [PATCH 1416/2175] Update Serialize and Deserialize a Binary Tree.java

---
 ...rialize and Deserialize a Binary Tree.java | 78 ++++++++++---------
 1 file changed, 40 insertions(+), 38 deletions(-)

diff --git a/Hard/Serialize and Deserialize a Binary Tree.java b/Hard/Serialize and Deserialize a Binary Tree.java
index d8b992b7..7639f07a 100644
--- a/Hard/Serialize and Deserialize a Binary Tree.java	
+++ b/Hard/Serialize and Deserialize a Binary Tree.java	
@@ -9,48 +9,50 @@
  */
 public class Codec {
 
-    // Encodes a tree to a single string.
-    public String serialize(TreeNode root) {
-        StringBuilder sb = new StringBuilder();
-        serializeHelper(root, sb);
-        return sb.toString().substring(0, sb.length() - 1);
+  private static final String NULL_VALUE = "-";
+  private static final String DELIMETER = " ";
+  
+  // Encodes a tree to a single string.
+  public String serialize(TreeNode root) {
+    if (root == null) {
+      return NULL_VALUE;
     }
-    
-    private void serializeHelper(TreeNode root, StringBuilder sb) {
-        if (root == null) {
-            sb.append("#").append(",");
-            return;
-        }
-        
-        sb.append(root.val).append(",");
-        serializeHelper(root.left, sb);
-        serializeHelper(root.right, sb);
+    StringBuilder sb = new StringBuilder();
+    Stack<TreeNode> stack = new Stack<>();
+    stack.add(root);
+    while (!stack.isEmpty()) {
+      TreeNode removed = stack.pop();
+      if (removed == null) {
+        sb.append(NULL_VALUE).append(DELIMETER);
+        continue;      
+      }
+      sb.append(removed.val).append(DELIMETER);
+      stack.push(removed.right);
+      stack.push(removed.left);
     }
+    return sb.toString().trim();
+  }
 
-    // Decodes your encoded data to tree.
-    public TreeNode deserialize(String data) {
-        Queue<String> values = new LinkedList<>(Arrays.asList(data.split(",")));
-        return deserializeHelper(values);
-    }
-    
-    private TreeNode deserializeHelper(Queue<String> values) {
-        if (values.isEmpty()) {
-            return null;
-        }
-        
-        String val = values.remove();
-        if (val.equals("#")) {
-            return null;
-        }
-        
-        TreeNode root = new TreeNode(Integer.parseInt(val));
-        root.left = deserializeHelper(values);
-        root.right = deserializeHelper(values);
-        
-        return root;
+  // Decodes your encoded data to tree.
+  public TreeNode deserialize(String data) {
+    Queue<String> queue = new LinkedList<>(Arrays.asList(data.split("\\s+")));
+    return helper(queue);
+  }
+  
+  private TreeNode helper(Queue<String> queue) {
+    if (queue.peek().equals(NULL_VALUE)) {
+      queue.remove();
+      return null;
     }
+    TreeNode root = new TreeNode(Integer.parseInt(queue.peek()));
+    queue.remove();
+    root.left = helper(queue);
+    root.right = helper(queue);
+    return root;
+  }
 }
 
 // Your Codec object will be instantiated and called as such:
-// Codec codec = new Codec();
-// codec.deserialize(codec.serialize(root));
+// Codec ser = new Codec();
+// Codec deser = new Codec();
+// TreeNode ans = deser.deserialize(ser.serialize(root));

From 46e6b097c8aa58f0f26f6f71e741d36b7f42d711 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Oct 2022 14:12:26 -0700
Subject: [PATCH 1417/2175] Update Serialize and Deserialize BST.java

---
 Medium/Serialize and Deserialize BST.java | 84 ++++++++++++-----------
 1 file changed, 43 insertions(+), 41 deletions(-)

diff --git a/Medium/Serialize and Deserialize BST.java b/Medium/Serialize and Deserialize BST.java
index 7f740386..ff587f9d 100644
--- a/Medium/Serialize and Deserialize BST.java	
+++ b/Medium/Serialize and Deserialize BST.java	
@@ -10,51 +10,53 @@
 public class Codec {
 
     // Encodes a tree to a single string.
-    public StringBuilder  sb;
-    public String serialize(TreeNode root) {
-        if (root == null) {
-            return "#";
-        }
-
-        sb = new StringBuilder();
-        serializeHelper(root);
-        return sb.toString();
+  public String serialize(TreeNode root) {
+    if (root == null) {
+      return "";
     }
-
-    private void serializeHelper(TreeNode root) {
-        if (root == null) {
-            sb.append('#').append(',');
-            return;
-        }
-
-        sb.append(root.val).append(',');
-        serializeHelper(root.left);
-        serializeHelper(root.right);
+    StringBuilder sb = new StringBuilder();
+    dfs(root, sb);
+    return sb.toString().trim();
+  }
+  
+  private void dfs(TreeNode root, StringBuilder sb) {
+    if (root == null) {
+      return;
     }
-
-    // Decodes your encoded data to tree.
-    public TreeNode deserialize(String data) {
-        Queue<String> q = new LinkedList<>(Arrays.asList(data.split(",")));
-        return deserializeHelper(q);
+    sb.append(root.val).append(" ");
+    dfs(root.left, sb);
+    dfs(root.right, sb);
+  }
+
+  // Decodes your encoded data to tree.
+  public TreeNode deserialize(String data) {
+    if (data.length() == 0) {
+      return null;
     }
-
-    private TreeNode deserializeHelper(Queue<String> queue) {
-        if (queue.isEmpty()) {
-            return null;
-        }
-        String s = queue.remove();
-        if (s.equals("#")) {
-            return null;
-        }
-
-        TreeNode root = new TreeNode(Integer.parseInt(s));
-        root.left = deserializeHelper(queue);
-        root.right = deserializeHelper(queue);
-
-        return root;
+    String[] split = data.split("\\s+");
+    return buildBST(split, 0, split.length - 1);
+  }
+  
+  private TreeNode buildBST(String[] data, int start, int end) {
+    if (start > end) {
+      return null;
+    }
+    TreeNode root = new TreeNode(Integer.parseInt(data[start]));
+    int index;
+    for (index = start; index <= end; index++) {
+      if (Integer.parseInt(data[index]) > Integer.parseInt(data[start])) {
+        break;
+      }
     }
+    root.left = buildBST(data, start + 1, index - 1);
+    root.right = buildBST(data, index, end);
+    return root;
+  }
 }
 
 // Your Codec object will be instantiated and called as such:
-// Codec codec = new Codec();
-// codec.deserialize(codec.serialize(root));
+// Codec ser = new Codec();
+// Codec deser = new Codec();
+// String tree = ser.serialize(root);
+// TreeNode ans = deser.deserialize(tree);
+// return ans;

From 3daa52aee46459ef2be9182cd6be2632678961d9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 13 Oct 2022 12:41:29 -0700
Subject: [PATCH 1418/2175] Update Number of Squareful Arrays.java

---
 Hard/Number of Squareful Arrays.java | 56 +++++++++++++---------------
 1 file changed, 26 insertions(+), 30 deletions(-)

diff --git a/Hard/Number of Squareful Arrays.java b/Hard/Number of Squareful Arrays.java
index 5903c367..b21f3889 100644
--- a/Hard/Number of Squareful Arrays.java	
+++ b/Hard/Number of Squareful Arrays.java	
@@ -1,39 +1,35 @@
 class Solution {
-  public int numSquarefulPerms(int[] A) {
-    Map<Integer, Integer> count = new HashMap<>();
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    int n = A.length;
-    for (int num : A) {
-      count.put(num, count.getOrDefault(num, 0) + 1);
+  public int numSquarefulPerms(int[] nums) {
+    Arrays.sort(nums);
+    int[] count = {0};
+    backtrack(new ArrayList<>(), nums, new boolean[nums.length], -1, count);
+    return count[0];
+  }
+  
+  private void backtrack(List<Integer> temp, int[] nums, boolean[] used, int lastNumber, int[] count) {
+    if (temp.size() == nums.length){
+      count[0]++;
+      return;
     }
-    for (Integer key1 : count.keySet()) {
-      graph.computeIfAbsent(key1, k -> new ArrayList<>());
-      for (Integer key2 : count.keySet()) {
-        int r = (int) (Math.sqrt(key1 + key2) + 0.5);
-        if (r * r == key1 + key2) {
-          graph.get(key1).add(key2);
+    for (int i = 0; i < nums.length; i++){
+      if (used[i] || (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])){
+        continue;
+      }
+      if (lastNumber != -1) {
+        if (!isSquare(nums[i] + lastNumber)) {
+          continue;
         }
       }
+      used[i] = true;
+      temp.add(nums[i]);
+      backtrack(temp, nums, used, nums[i], count);
+      temp.remove(temp.size() - 1);
+      used[i] = false;
     }
-    int ans = 0;
-    for (Integer key : count.keySet()) {
-      ans += dfs(key, n - 1, count, graph);
-    }
-    return ans;
   }
   
-  private int dfs(int key, int toReach, Map<Integer, Integer> count, Map<Integer, List<Integer>> graph) {
-    count.put(key, count.get(key) - 1);
-    int currAns = 1;
-    if (toReach != 0) {
-      currAns = 0;
-      for (int node : graph.get(key)) {
-        if (count.get(node) != 0) {
-          currAns += dfs(node, toReach - 1, count, graph);
-        }
-      }
-    }
-    count.put(key, count.get(key) + 1);
-    return currAns;
+  private boolean isSquare(int num) {
+    int squareRoot = (int) Math.sqrt(num);
+    return squareRoot * squareRoot == num;
   }
 }

From d751ef0f04454a9cfc3ffcc7c481a0fe8f343383 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 14 Oct 2022 11:00:07 -0700
Subject: [PATCH 1419/2175] Update Construct Binary Tree from Inorder and
 Postorder Traversal.java

---
 ... from Inorder and Postorder Traversal.java | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/Medium/Construct Binary Tree from Inorder and Postorder Traversal.java b/Medium/Construct Binary Tree from Inorder and Postorder Traversal.java
index 9e69f9f5..ce312c11 100644
--- a/Medium/Construct Binary Tree from Inorder and Postorder Traversal.java	
+++ b/Medium/Construct Binary Tree from Inorder and Postorder Traversal.java	
@@ -14,24 +14,23 @@
  * }
  */
 class Solution {
-  int idx;
   public TreeNode buildTree(int[] inorder, int[] postorder) {
     Map<Integer, Integer> map = new HashMap<>();
     for (int i = 0; i < inorder.length; i++) {
       map.put(inorder[i], i);
     }
-    idx = postorder.length - 1;
-    return helper(inorder, postorder, 0, postorder.length - 1, map);
+    int[] postIdx = {postorder.length - 1}; 
+    return helper(postorder, map, 0, inorder.length - 1, postIdx);
   }
   
-  private TreeNode helper(int[] inorder, int[] postorder, int start, int end, Map<Integer, Integer> map) {
-    if (start > end) {
+  private TreeNode helper(int[] postorder, Map<Integer, Integer> map, int leftIdx, int rightIdx, int[] postIdx) {
+    if (leftIdx > rightIdx) {
       return null;
     }
-    TreeNode node = new TreeNode(postorder[idx]);
-    int pos = map.get(postorder[idx--]);
-    node.right = helper(inorder, postorder, pos + 1, end, map);
-    node.left = helper(inorder, postorder, start, pos - 1, map);
-    return node;
+    TreeNode root = new TreeNode(postorder[postIdx[0]--]);
+    int index = map.get(root.val);
+    root.right = helper(postorder, map, index + 1, rightIdx, postIdx);
+    root.left = helper(postorder, map, leftIdx, index - 1, postIdx);
+    return root;
   }
 }

From 4212d3c36d3f79d7b7ec9e72db2caf8a6413b6f2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 14 Oct 2022 11:31:11 -0700
Subject: [PATCH 1420/2175] Create Minimum Window Subsequence.java

---
 Hard/Minimum Window Subsequence.java | 29 ++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Hard/Minimum Window Subsequence.java

diff --git a/Hard/Minimum Window Subsequence.java b/Hard/Minimum Window Subsequence.java
new file mode 100644
index 00000000..88c2a006
--- /dev/null
+++ b/Hard/Minimum Window Subsequence.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public String minWindow(String s1, String s2) {
+    String window = "";
+    int j = 0;
+    int minLength = s1.length() + 1;
+    for (int i = 0; i < s1.length(); i++) {
+      if (s1.charAt(i) == s2.charAt(j)) {
+        j++;
+        if (j == s2.length()) {
+          int end = i + 1;
+          j--;
+          while (j >= 0) {
+            if (s1.charAt(i) == s2.charAt(j)) {
+              j--;
+            }
+            i--;
+          }
+          j++;
+          i++;
+          if (end - i < minLength) {
+            minLength = end - i;
+            window = s1.substring(i, end);
+          }
+        }
+      }
+    }
+    return window;
+  }
+}

From 1da3db3625fcedbb5c7c80ae55f244b0f8b98ead Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 15 Oct 2022 11:04:02 -0700
Subject: [PATCH 1421/2175] Create Similar RGB Color.java

---
 Easy/Similar RGB Color.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Similar RGB Color.java

diff --git a/Easy/Similar RGB Color.java b/Easy/Similar RGB Color.java
new file mode 100644
index 00000000..968464dc
--- /dev/null
+++ b/Easy/Similar RGB Color.java	
@@ -0,0 +1,16 @@
+class Solution {
+  public String similarRGB(String color) {
+    StringBuilder simlarColor = new StringBuilder();
+    simlarColor.append("#");
+    for (int i = 1; i < 6; i += 2) {
+      simlarColor.append(findClosestColor(color.substring(i, i + 2)));
+    }
+    return simlarColor.toString();
+  }
+  
+  private String findClosestColor(String section) {
+    int num = Integer.parseInt(section, 16);
+    int roundedValue = Math.round((float) num / 17);
+    return Integer.toHexString(roundedValue).repeat(2);
+  }
+}

From 475006567f14af79eec3705a8da2dccd469b6b03 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 15 Oct 2022 12:07:13 -0700
Subject: [PATCH 1422/2175] Create String Compression II.java

---
 Hard/String Compression II.java | 69 +++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 Hard/String Compression II.java

diff --git a/Hard/String Compression II.java b/Hard/String Compression II.java
new file mode 100644
index 00000000..d2f3d371
--- /dev/null
+++ b/Hard/String Compression II.java	
@@ -0,0 +1,69 @@
+class Solution {
+  
+  /**
+  * First dimension : Current index
+  * Second dimension : Amount of available deletions
+  * Third dimension : Index of previous character
+  * Fourth dimension : Consecutive count of previous character
+  */
+  private static int[][][][] dp = new int[100][101][100][26];
+  
+  public int getLengthOfOptimalCompression(String s, int k) {
+    int n = s.length();
+    for(int i = 0; i < n; i++) {
+      for(int j = 0; j <= k; j++) {
+        for(int z = 0; z < n; z++) {
+          for(int l = 0; l < 26; l++) {
+            dp[i][j][z][l]=-1;
+          }
+        }
+      }
+    }
+    return best(s.toCharArray(), /* idx= */ 0, k, /* count= */ 0, /* prevChar= */ s.charAt(0));
+  }
+  
+  private int best(char[] letters, int idx, int k, int count, char prevChar) {
+    if (idx == letters.length) {
+      return countNumberOfLetters(count);
+    }
+    if (dp[idx][k][count][prevChar - 'a'] != -1) {
+      return dp[idx][k][count][prevChar - 'a'];
+    }
+    if (k == 0) {
+      int result = 0;
+      if (letters[idx] == prevChar) {
+        result = best(letters, idx + 1, k, count + 1, prevChar);
+      } else {
+        result = countNumberOfLetters(count) + best(letters, idx + 1, k, 1, letters[idx]);
+      }
+      dp[idx][k][count][prevChar - 'a'] = result;
+      return result;
+    }
+    int result = 0;
+    if (letters[idx] == prevChar) {
+      result = Math.min(
+        best(letters, idx + 1, k, count + 1, prevChar), // Delete and recurse forward
+        best(letters, idx + 1, k - 1, count, prevChar)); // Don't delete and recurse forward
+    } else {
+      result = Math.min(
+        countNumberOfLetters(count) + best(letters, idx + 1, k, /* count= */ 1, /* prevChar= */ letters[idx]), // Don't delete current char and recurse forward with new count
+        best(letters, idx + 1, k - 1, count, prevChar)); // Delete current character and recurse forward
+    }
+    dp[idx][k][count][prevChar - 'a'] = result;
+    return result;
+  }
+  
+  private static int countNumberOfLetters(int count) {
+    if (count == 0) {
+      return count;
+    }
+    int numberOfDigits = 1;
+    if (count > 9) {
+      numberOfDigits = 2;
+    } 
+    if (count > 99) {
+      numberOfDigits = 3;
+    }
+    return count == 1 ? 1 : (numberOfDigits + 1);
+  }
+}

From 2d6e01c44043a590ed4744774a7647f93da16437 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 16 Oct 2022 06:49:18 -0700
Subject: [PATCH 1423/2175] Create Largest Positive Integer That Exists With
 Its Negative.java

---
 ...itive Integer That Exists With Its Negative.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Largest Positive Integer That Exists With Its Negative.java

diff --git a/Easy/Largest Positive Integer That Exists With Its Negative.java b/Easy/Largest Positive Integer That Exists With Its Negative.java
new file mode 100644
index 00000000..b6789be7
--- /dev/null
+++ b/Easy/Largest Positive Integer That Exists With Its Negative.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int findMaxK(int[] nums) {
+    int largestNumber = -1;
+    Set<Integer> set = new HashSet<>();
+    for (int num : nums) {
+      if (set.contains(-1 * num)) {
+        largestNumber = Math.max(Math.abs(num), largestNumber);
+      }
+      set.add(num);
+    }
+    return largestNumber;
+  }
+}

From 63bbb86862d3aec7c828d1809178100d66c6bc7e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 16 Oct 2022 06:52:59 -0700
Subject: [PATCH 1424/2175] Create Count Number of Distinct Integers After
 Reverse Operations.java

---
 ...nct Integers After Reverse Operations.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Count Number of Distinct Integers After Reverse Operations.java

diff --git a/Medium/Count Number of Distinct Integers After Reverse Operations.java b/Medium/Count Number of Distinct Integers After Reverse Operations.java
new file mode 100644
index 00000000..ecf51e81
--- /dev/null
+++ b/Medium/Count Number of Distinct Integers After Reverse Operations.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int countDistinctIntegers(int[] nums) {
+    Set<Integer> set = new HashSet<>();
+    for (int num : nums) {
+      set.add(num);
+      set.add(reverse(num));
+    }
+    return set.size();
+  }
+  
+  private int reverse(int num) {
+    int reversed = 0;
+    while (num > 0) {
+      reversed = reversed * 10 + num % 10;
+      num /= 10;
+    }
+    return reversed;
+  }
+}

From 2e85346157382e37ab301c7d81113c7745c3206a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 16 Oct 2022 09:49:34 -0700
Subject: [PATCH 1425/2175] Create Minimum Difficulty of a Job Schedule.java

---
 .../Minimum Difficulty of a Job Schedule.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Hard/Minimum Difficulty of a Job Schedule.java

diff --git a/Hard/Minimum Difficulty of a Job Schedule.java b/Hard/Minimum Difficulty of a Job Schedule.java
new file mode 100644
index 00000000..58722245
--- /dev/null
+++ b/Hard/Minimum Difficulty of a Job Schedule.java	
@@ -0,0 +1,30 @@
+class Solution {
+  public int minDifficulty(int[] jobDifficulty, int d) {
+    int n = jobDifficulty.length;
+    if (n < d) {
+      return -1;
+    }
+    Integer[][] dp = new Integer[n][d + 1];
+    return minDifficulty(/* index= */0, d, jobDifficulty, dp);
+  }
+  
+  private int minDifficulty(int index, int dLeft, int[] jobDifficulty, Integer[][] dp)  {
+    if (dp[index][dLeft] != null) {
+      return dp[index][dLeft];
+    }
+    if (dLeft == 1) {
+      int result = 0;
+      for (int j = index; j < jobDifficulty.length; j++) {
+        result = Math.max(result, jobDifficulty[j]);
+      }
+      return result;
+    }
+    int result = Integer.MAX_VALUE;
+    int dailyMaxJobDiff = 0;
+    for (int j = index; j < jobDifficulty.length - dLeft + 1; j++) {
+      dailyMaxJobDiff = Math.max(dailyMaxJobDiff, jobDifficulty[j]);
+      result = Math.min(result, dailyMaxJobDiff + minDifficulty(j + 1, dLeft - 1, jobDifficulty, dp));
+    }
+    return dp[index][dLeft] = result;
+  } 
+}

From ec562bb60f71364c6f47356487c34c20fa3f2443 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 17 Oct 2022 08:15:42 -0700
Subject: [PATCH 1426/2175] Update Find the City With the Smallest Number of
 Neighbors at a Threshold Distance.java

---
 ... of Neighbors at a Threshold Distance.java | 62 +++++++++++--------
 1 file changed, 35 insertions(+), 27 deletions(-)

diff --git a/Medium/Find the City With the Smallest Number of Neighbors at a Threshold Distance.java b/Medium/Find the City With the Smallest Number of Neighbors at a Threshold Distance.java
index 08292d1d..92c4b6a4 100644
--- a/Medium/Find the City With the Smallest Number of Neighbors at a Threshold Distance.java	
+++ b/Medium/Find the City With the Smallest Number of Neighbors at a Threshold Distance.java	
@@ -1,37 +1,45 @@
 class Solution {
   public int findTheCity(int n, int[][] edges, int distanceThreshold) {
-    Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
+    Map<Integer, List<int[]>> graph = new HashMap<>();
     for (int[] edge : edges) {
-      map.computeIfAbsent(edge[0], k -> new HashMap<>()).put(edge[1], edge[2]);
-      map.computeIfAbsent(edge[1], k -> new HashMap<>()).put(edge[0], edge[2]);
+      graph.computeIfAbsent(edge[0], k -> new ArrayList<>())
+          .add(new int[]{edge[1], edge[2]});
+      graph.computeIfAbsent(edge[1], k -> new ArrayList<>())
+          .add(new int[]{edge[0], edge[2]});
     }
-    int min = n + 1;
-    int res = -1;
+    int minNeighborCount = n + 1;
+    int nodeWithMinNeighbor = -1;
     for (int i = 0; i < n; i++) {
-      Queue<int[]> queue = new PriorityQueue<>((a, b) -> (b[1] - a[1]));
-      queue.add(new int[]{i, distanceThreshold});
-      boolean[] visited = new boolean[n];
-      int count = 0;
-      while (!queue.isEmpty()) {
-        int[] city = queue.poll();
-        if (visited[city[0]]) {
-          continue;
-        }
-        visited[city[0]] = true;
-        count++;
-        Map<Integer, Integer> temp = map.getOrDefault(city[0], new HashMap<>());
-        for (Integer neighbour : temp.keySet()) {
-          if (!visited[neighbour] && city[1] >= temp.get(neighbour)) {
-            queue.add(new int[]{neighbour, city[1] - temp.get(neighbour)});
-          }
-        }
+      int numOfNeighbors = findNumberOfNeighborsWithinThresholdDistance(i, distanceThreshold, graph);
+      minNeighborCount = Math.min(numOfNeighbors, minNeighborCount);
+      nodeWithMinNeighbor = minNeighborCount == numOfNeighbors ? i : nodeWithMinNeighbor;
+    }
+    return nodeWithMinNeighbor;
+  }
+
+  private int findNumberOfNeighborsWithinThresholdDistance(int node, int distanceThreshold, Map<Integer, List<int[]>> graph) {
+    Queue<int[]> queue = new PriorityQueue<>((a, b) -> (b[1] - a[1]));
+    Set<Integer> visited = new HashSet<>();
+    queue.add(new int[]{node, distanceThreshold});
+    int numOfNeighbors = 0;
+    while (!queue.isEmpty()) {
+      int[] removed = queue.remove();
+      int currNode = removed[0];
+      int currDistanceThreshold = removed[1];
+      if (visited.contains(currNode)) {
+        continue;
       }
-      if (count - 1 <= min) {
-        min = count - 1;
-        res = i;
+      visited.add(currNode);
+      numOfNeighbors++;
+      for (int[] neighbor : graph.getOrDefault(currNode, new ArrayList<>())) {
+        int neighborNode = neighbor[0];
+        int neighborDistance = neighbor[1];
+        if (!visited.contains(neighborNode) &&
+            currDistanceThreshold >= neighborDistance) {
+          queue.add(new int[]{neighborNode, currDistanceThreshold - neighborDistance});
+        }
       }
     }
-    return res;
+    return numOfNeighbors;
   }
 }
-

From 0cc6bf7bec60cd907cb7cec5b27ed3bad9781b73 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Oct 2022 07:16:07 -0700
Subject: [PATCH 1427/2175] Create Wildcard Matching.java

---
 Hard/Wildcard Matching.java | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Hard/Wildcard Matching.java

diff --git a/Hard/Wildcard Matching.java b/Hard/Wildcard Matching.java
new file mode 100644
index 00000000..993a9f62
--- /dev/null
+++ b/Hard/Wildcard Matching.java	
@@ -0,0 +1,32 @@
+class Solution {
+  public boolean isMatch(String s, String p) {
+    int sLen = s.length();
+    int pLen = p.length();
+    int sIdx = 0;
+    int pIdx = 0;
+    int startIdx = -1;
+    int sTempIdx = -1;
+    while (sIdx < sLen) {
+      if (pIdx < pLen && (p.charAt(pIdx) == '?' || p.charAt(pIdx) == s.charAt(sIdx))) {
+        sIdx++;
+        pIdx++;
+      } else if (pIdx < pLen && p.charAt(pIdx) == '*') {
+        startIdx = pIdx;
+        sTempIdx = sIdx;
+        pIdx++;
+      } else if (startIdx == -1) {
+        return false;
+      } else {
+        pIdx = startIdx + 1;
+        sIdx = sTempIdx + 1;
+        sTempIdx = sIdx;
+      }
+    }
+    for (int i = pIdx; i < pLen; i++) {
+      if (p.charAt(i) != '*') {
+        return false;
+      }
+    }
+    return true;
+  }
+}

From 0576cafff7971353706e956998558e0e36bacf9d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Oct 2022 08:16:46 -0700
Subject: [PATCH 1428/2175] Update Edit Distance.java

---
 Hard/Edit Distance.java | 48 ++++++++++++++++++-----------------------
 1 file changed, 21 insertions(+), 27 deletions(-)

diff --git a/Hard/Edit Distance.java b/Hard/Edit Distance.java
index e3428cdc..c4000645 100644
--- a/Hard/Edit Distance.java	
+++ b/Hard/Edit Distance.java	
@@ -1,32 +1,26 @@
 class Solution {
-    public int minDistance(String s1, String s2) {
-        return minDistanceHelperDP(s1, s2, s1.length(), s2.length());
+  public int minDistance(String word1, String word2) {
+    int n = word1.length();
+    int m = word2.length();
+    if (n * m == 0) {
+      return n + m;
     }
-    
-    private int minDistanceHelperDP(String s1, String s2, int m, int n) {
-        int[][] dp = new int[m+1][n+1];
-
-        for (int i=0;i<=m;i++) {
-            for (int j=0;j<=n;j++) {
-                // First substring is empty
-                if (i == 0) {
-                    dp[i][j] = j;
-                }
-                // Second substring is empty
-                else if (j == 0) {
-                    dp[i][j] = i;
-                }
-                // If character are same, value is same as the previous dp array
-                else if (s1.charAt(i-1) == s2.charAt(j-1)) {
-                    dp[i][j] = dp[i-1][j-1];
-                }
-                // If different, then 1 + min
-                else {
-                    dp[i][j] = 1 + Math.min(dp[i-1][j-1], Math.min(dp[i][j-1], dp[i-1][j]));
-                }
-            }
+    int[][] dp = new int[n + 1][m + 1];
+    for (int i = 0; i <= n; i++) {
+      dp[i][0] = i;
+    }
+    for (int j = 0; j <= m; j++) {
+      dp[0][j] = j;
+    }
+    for (int i = 1; i <= n; i++) {
+      for (int j = 1; j <= m; j++) {
+        if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
+          dp[i][j] = dp[i - 1][j - 1];
+        } else {
+          dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;
         }
-
-        return dp[m][n];
+      }
     }
+    return dp[n][m];
+  }
 }

From 6db7f6da4406a1b3e46814b7bec8f1884b6782a9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Oct 2022 08:43:52 -0700
Subject: [PATCH 1429/2175] Create Partition Equal Subset Sum.java

---
 Medium/Partition Equal Subset Sum.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Partition Equal Subset Sum.java

diff --git a/Medium/Partition Equal Subset Sum.java b/Medium/Partition Equal Subset Sum.java
new file mode 100644
index 00000000..41c71f7e
--- /dev/null
+++ b/Medium/Partition Equal Subset Sum.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public boolean canPartition(int[] nums) {
+    int sum = 0;
+    for (int num : nums) {
+      sum += num;
+    }
+    if (sum % 2 == 1) {
+      return false;
+    }
+    sum /= 2;
+    int n = nums.length;
+    boolean[] dp = new boolean[sum + 1];
+    dp[0] = true;
+    for (int num : nums) {
+      for (int i = sum; i > 0; i--) {
+        if (i >= num) {
+          dp[i] = dp[i] || dp[i - num];
+        }
+      }
+    }
+    return dp[sum];
+  }
+}

From 43a66786fb0437175300aa680b2604afb46292ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Oct 2022 08:44:42 -0700
Subject: [PATCH 1430/2175] Update Last Stone Weight II.java

---
 Medium/Last Stone Weight II.java | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/Medium/Last Stone Weight II.java b/Medium/Last Stone Weight II.java
index 73764b86..61c61dd6 100644
--- a/Medium/Last Stone Weight II.java	
+++ b/Medium/Last Stone Weight II.java	
@@ -1,19 +1,15 @@
 class Solution {
   public int lastStoneWeightII(int[] stones) {
-    boolean[] dp = new boolean[1501];
-    dp[0] = true;
     int sum = 0;
     for (int stone : stones) {
       sum += stone;
-      for (int i = Math.min(1500, sum); i >= stone; i--) {
-        dp[i] |= dp[i - stone]; 
-      }
     }
-    for (int i = sum / 2; i >= 0; i--) {
-      if (dp[i]) {
-        return sum - i - i;
+    int[] dp = new int[sum / 2 + 1];
+    for (int i = 1; i <= stones.length; i++) {
+      for (int j = sum / 2; j >= stones[i - 1]; j--) {
+        dp[j] = Math.max(dp[j], dp[j - stones[i - 1]] + stones[i - 1]);
       }
     }
-    return 0;
+    return sum - 2 * dp[sum / 2];
   }
 }

From 03835d34accc54de7fa3ca9bd028937d5aad1949 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Oct 2022 10:32:57 -0700
Subject: [PATCH 1431/2175] Update Element Appearing More Than 25% In Sorted
 Array.java

---
 ...pearing More Than 25% In Sorted Array.java | 77 ++++++++-----------
 1 file changed, 31 insertions(+), 46 deletions(-)

diff --git a/Easy/Element Appearing More Than 25% In Sorted Array.java b/Easy/Element Appearing More Than 25% In Sorted Array.java
index 139c2c07..966f0ce9 100644
--- a/Easy/Element Appearing More Than 25% In Sorted Array.java	
+++ b/Easy/Element Appearing More Than 25% In Sorted Array.java	
@@ -1,57 +1,42 @@
 class Solution {
+  
+  enum Direction {LEFT, RIGHT};
+  
   public int findSpecialInteger(int[] arr) {
     int n = arr.length;
-    int oneFourthNum = arr[n / 4];
-    int halfNum = arr[n / 2];
-    int threeFourthNum = arr[3 * n / 4];
-    if(Math.max(n/4, binarySearchRight(arr, 0, n - 1, oneFourthNum)) - 
-       Math.min(n/4, binarySearchLeft(arr, 0, n - 1, oneFourthNum)) >= arr.length / 4) {
-         return oneFourthNum;
-       }
-    if(Math.max(n/2, binarySearchRight(arr, 0, n - 1, halfNum)) - 
-       Math.min(n/2, binarySearchLeft(arr, 0, n - 1, halfNum)) >= arr.length / 4) {
-         return halfNum;
-       }
-    if(Math.max((3 * n)/4, binarySearchRight(arr, 0, n - 1, threeFourthNum)) - 
-       Math.min((3 * n)/4, binarySearchLeft(arr, 0, n - 1, threeFourthNum)) >= arr.length / 4) {
-         return threeFourthNum;
-       }
-    return -1;
-  }
-  
-  private int binarySearchLeft(int[] arr, int start, int end, int num) {
-    int minIdx = Integer.MAX_VALUE;
-    while (start < end) {
-      int mid = (start + end) / 2;
-      if (arr[mid] == num) {
-        minIdx = Math.min(mid, minIdx);
-        end = mid - 1;
-      }
-      else if (arr[mid] < num) {
-        start = mid + 1;
-      }
-      else {
-        end = mid - 1;
+    if (n == 1) {
+      return arr[0];
+    }
+    List<Integer> list = Arrays.asList(arr[n / 4], arr[n / 2], arr[3 * n / 4]);
+    for (int num : list) {
+      int firstPosition = getPosition(arr, num, Direction.LEFT);
+      int lastPosition = getPosition(arr, num, Direction.RIGHT);
+      if (lastPosition - firstPosition + 1 > n / 4) {
+        return num;
       }
     }
-    return minIdx;
+    return -1;
   }
   
-  private int binarySearchRight(int[] arr, int start, int end, int num) {
-    int maxIdx = Integer.MIN_VALUE;
-    while (start < end) {
-      int mid = (start + end) / 2;
-      if (arr[mid] == num) {
-        maxIdx = Math.max(mid, maxIdx);
-        start = mid + 1;
-      }
-      else if (arr[mid] < num) {
-        start = mid + 1;
-      }
-      else {
-        end = mid - 1;
+  private int getPosition(int[] nums, int num, Direction direction) {
+    int left = 0;
+    int right = nums.length - 1;
+    int idx = -1;
+    while (left <= right) {
+      int mid = (left + right) / 2;
+      if (nums[mid] == num) {
+        idx = mid;
+        if (direction == Direction.LEFT) {
+          right = mid - 1;
+        } else {
+          left = mid + 1;
+        }
+      } else if (nums[mid] > num) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
       }
     }
-    return maxIdx;
+    return idx;
   }
 }

From 9d404d95b8730e63a58a7f8ba2ae54673ac88dd3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Oct 2022 10:34:56 -0700
Subject: [PATCH 1432/2175] Create Find the Kth Smallest Sum of a Matrix With
 Sorted Rows.java

---
 ...lest Sum of a Matrix With Sorted Rows.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Hard/Find the Kth Smallest Sum of a Matrix With Sorted Rows.java

diff --git a/Hard/Find the Kth Smallest Sum of a Matrix With Sorted Rows.java b/Hard/Find the Kth Smallest Sum of a Matrix With Sorted Rows.java
new file mode 100644
index 00000000..e5800be2
--- /dev/null
+++ b/Hard/Find the Kth Smallest Sum of a Matrix With Sorted Rows.java	
@@ -0,0 +1,19 @@
+class Solution {
+  public int kthSmallest(int[][] mat, int k) {
+    PriorityQueue<Integer> prevSum = new PriorityQueue<>(Collections.reverseOrder());
+    prevSum.add(0);
+    for (int[] row : mat) {
+      PriorityQueue<Integer> nextSum = new PriorityQueue<>(Collections.reverseOrder());
+      for (int sum : prevSum) {
+        for (int c = 0; c < mat[0].length; c++) {
+          nextSum.add(sum + row[c]);
+          if (nextSum.size() > k) {
+            nextSum.poll();
+          }
+        }
+      }
+      prevSum = nextSum;
+    }
+    return prevSum.poll();
+  }
+}

From 5cad9a67848452fa35aad1b13247892e476ec3a8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Oct 2022 12:14:20 -0700
Subject: [PATCH 1433/2175] Update First Unique Number.java

---
 Medium/First Unique Number.java | 85 +++++++++++++++++++--------------
 1 file changed, 48 insertions(+), 37 deletions(-)

diff --git a/Medium/First Unique Number.java b/Medium/First Unique Number.java
index 9a0dd44e..d5406335 100644
--- a/Medium/First Unique Number.java	
+++ b/Medium/First Unique Number.java	
@@ -1,56 +1,67 @@
 class FirstUnique {
-  Node head;
-  Node tail;
-  Map<Integer, Node> map;
-  int MX_VAL = Integer.MAX_VALUE;
-  int MN_VAL = Integer.MIN_VALUE;
+  
+  private Node head;
+  private Node tail;
+  private Map<Integer, Node> map;
+  
   public FirstUnique(int[] nums) {
-    map = new HashMap<>();
-    head = new Node(MN_VAL);
-    tail = new Node(MX_VAL);
-    head.next = tail;
-    tail.prev = head;
+    this.head = new Node(-1);
+    this.tail = new Node(-1);
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+    this.map = new HashMap<>();
     for (int num : nums) {
-      add(num);
+      if (map.containsKey(num)) {
+        deleteNode(map.get(num));
+      } else {
+        Node node = new Node(num);
+        map.put(num, node);
+        addToTail(node);
+      }
     }
   }
 
   public int showFirstUnique() {
-    return head.next.val == MX_VAL ? -1 : head.next.val;
+    return this.head.next.val;
   }
 
   public void add(int value) {
     if (map.containsKey(value)) {
-      if (map.get(value) != null) {
-        remove(map.get(value));
-        map.put(value, null);
-      }
-    }
-    else {
-      Node newNode = new Node(value);
-      map.put(value, newNode);
-      newNode.prev = tail.prev;
-      tail.prev.next = newNode;
-      newNode.next = tail;
-      tail.prev = newNode;
+      deleteNode(map.get(value));
+      return;
     }
+    Node node = new Node(value);
+    map.put(value, node);
+    addToTail(node);
   }
   
-  private void remove(Node node) {
-    Node prev = node.prev;
-    Node next = node.next;
-    prev.next = next;
-    next.prev = prev;
+  private void addToTail(Node node) {
+    Node prevToTail = this.tail.prev;
+    prevToTail.next = node;
+    node.next = this.tail;
+    node.prev = prevToTail;
+    this.tail.prev = node;
   }
-}
-
-class Node {
-  int val;
-  Node next;
-  Node prev;
   
-  public Node(int val) {
-    this.val = val;
+  private void deleteNode(Node node) {
+    if (node == null) {
+      return;
+    }
+    map.put(node.val, null);
+    Node prevToNode = node.prev;
+    Node nextToNode = node.next;
+    prevToNode.next = nextToNode;
+    nextToNode.prev = prevToNode;
+  }
+  
+  private static class Node {
+    int val;
+    Node next;
+    Node prev;
+    
+    public Node(int val) {
+      this.val = val;
+    }
   }
 }
 

From 9fd4a9da9bfe9e7310ddf9c5982e58012e46dda4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 18 Oct 2022 17:17:16 -0700
Subject: [PATCH 1434/2175] Update Find Minimum in Rotated Sorted Array.java

---
 .../Find Minimum in Rotated Sorted Array.java | 45 +++++++++++--------
 1 file changed, 27 insertions(+), 18 deletions(-)

diff --git a/Medium/Find Minimum in Rotated Sorted Array.java b/Medium/Find Minimum in Rotated Sorted Array.java
index ef50804a..8c18f17b 100644
--- a/Medium/Find Minimum in Rotated Sorted Array.java	
+++ b/Medium/Find Minimum in Rotated Sorted Array.java	
@@ -1,21 +1,30 @@
 class Solution {
-    public int findMin(int[] nums) {
-        int start = 0;
-        int end = nums.length-1;
-        while (start <= end) {
-            int mid = (start + end)/2;
-
-            if (((mid > 0 ? nums[mid] < nums[mid-1] : true) && (mid < nums.length-1 ? nums[mid] < nums[mid+1] : true))) {
-                return nums[mid];
-            }
-            else if (nums[mid] < nums[end]) {
-                end = mid-1;
-            }
-            else {
-                start = mid+1;
-            }
-        }
-
-        return -1;
+  public int findMin(int[] nums) {
+    if (nums.length == 1) {
+      return nums[0];
     }
+    int left = 0;
+    int right = nums.length - 1;
+    // Sorted but not rotated
+    if (nums[right] > nums[left]) {
+      return nums[left];
+    }
+    while (left <= right) {
+      int mid = (left + right) / 2;
+      // mid + 1 is point of rotation
+      if (nums[mid] > nums[mid + 1]) {
+        return nums[mid + 1];
+      }
+      // mid is point of rotation
+      if (nums[mid - 1] > nums[mid]) {
+        return nums[mid];
+      }
+      if (nums[mid] > nums[0]) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+    return Integer.MAX_VALUE;
+  }
 }

From b1bcff17828b9a55239b3fb50f64b6aedfc91230 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 Oct 2022 15:01:46 -0700
Subject: [PATCH 1435/2175] Update Set Mismatch.java

---
 Easy/Set Mismatch.java | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/Easy/Set Mismatch.java b/Easy/Set Mismatch.java
index f18f0a5c..9660688d 100644
--- a/Easy/Set Mismatch.java	
+++ b/Easy/Set Mismatch.java	
@@ -1,14 +1,18 @@
-import java.util.Map.Entry;
-
 class Solution {
   public int[] findErrorNums(int[] nums) {
-    HashMap<Integer, Long> frequencyMap = Arrays.stream(nums).boxed()
-        .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
-    return new int[]{
-        frequencyMap.entrySet().stream().filter(entry -> entry.getValue().equals(2L))
-            .map(Entry::getKey).findFirst().orElse(-1),
-        IntStream.range(1, nums.length + 1).boxed().filter(key -> !frequencyMap.containsKey(key))
-            .findFirst().orElse(-1)
-    };
+    int[] result = new int[2];
+    Set<Integer> set = new HashSet<>();
+    int n = nums.length;
+    for (int num : nums) {
+      if (!set.add(num)) {
+        result[0] = num;
+      }
+    }
+    for (int i = 1; i <= n; i++) {
+      if (!set.contains(i)) {
+        result[1] = i;
+      }
+    }
+    return result;
   }
 }

From 1e059b4532fdb15934439cf1a72a29aa312fa0ef Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 26 Oct 2022 08:15:25 -0700
Subject: [PATCH 1436/2175] Create Determine if Two Events Have Conflict.java

---
 Easy/Determine if Two Events Have Conflict.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Determine if Two Events Have Conflict.java

diff --git a/Easy/Determine if Two Events Have Conflict.java b/Easy/Determine if Two Events Have Conflict.java
new file mode 100644
index 00000000..66c19dce
--- /dev/null
+++ b/Easy/Determine if Two Events Have Conflict.java	
@@ -0,0 +1,14 @@
+class Solution {
+  public boolean haveConflict(String[] event1, String[] event2) {
+    int minutesEvent1Start = getMinutes(event1[0]);
+    int minutesEvent1End = getMinutes(event1[1]);
+    int minutesEvent2Start = getMinutes(event2[0]);
+    int minutesEvent2End = getMinutes(event2[1]);
+    return !(minutesEvent1End < minutesEvent2Start || minutesEvent2End < minutesEvent1Start);
+  }
+  
+  private static int getMinutes(String time) {
+    String[] split = time.split(":");
+    return Integer.parseInt(split[0]) * 60 + Integer.parseInt(split[1]);
+  }
+}

From 46bd91078f416c95eb42da0018ad857c47ec359b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 27 Oct 2022 07:31:19 -0700
Subject: [PATCH 1437/2175] Create Image Overlap.java

---
 Medium/Image Overlap.java | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Image Overlap.java

diff --git a/Medium/Image Overlap.java b/Medium/Image Overlap.java
new file mode 100644
index 00000000..680b1750
--- /dev/null
+++ b/Medium/Image Overlap.java	
@@ -0,0 +1,29 @@
+class Solution {
+  public int largestOverlap(int[][] img1, int[][] img2) {
+    List<Pair<Integer, Integer>> nonZeroCoordinates1 = getNonZeroCoordinates(img1);
+    List<Pair<Integer, Integer>> nonZeroCoordinates2 = getNonZeroCoordinates(img2);
+    int maxOverlap = 0;
+    Map<Pair<Integer, Integer>, Integer> groupCount = new HashMap<>();
+    for (Pair<Integer, Integer> c1 : nonZeroCoordinates1) {
+      for (Pair<Integer, Integer> c2 : nonZeroCoordinates2) {
+        Pair<Integer, Integer> vector = new Pair<Integer, Integer>(
+          c2.getKey() - c1.getKey(), c2.getValue() - c1.getValue());
+        groupCount.put(vector, groupCount.getOrDefault(vector, 0) + 1);
+        maxOverlap = Math.max(maxOverlap, groupCount.get(vector));
+      }
+    }
+    return maxOverlap;
+  }
+  
+  private List<Pair<Integer, Integer>> getNonZeroCoordinates(int[][] arr) {
+    List<Pair<Integer, Integer>> coordinates = new ArrayList<>();
+    for (int i = 0; i < arr.length; i++) {
+      for (int j = 0; j < arr[0].length; j++) {
+        if (arr[i][j] == 1) {
+          coordinates.add(new Pair(i, j));
+        }
+      }
+    }
+    return coordinates;
+  }
+}

From 3054444bd56ace22ba2c84b6f93c08b724b56607 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Oct 2022 07:06:14 -0700
Subject: [PATCH 1438/2175] Create Odd String Difference.java

---
 Easy/Odd String Difference.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Odd String Difference.java

diff --git a/Easy/Odd String Difference.java b/Easy/Odd String Difference.java
new file mode 100644
index 00000000..d6fa4b49
--- /dev/null
+++ b/Easy/Odd String Difference.java	
@@ -0,0 +1,23 @@
+class Solution {
+  public String oddString(String[] words) {
+    Map<String, Set<String>> diffCounter = new HashMap<>();
+    for (String word : words) {
+      String key = getDiffCounter(word);
+      diffCounter.computeIfAbsent(key, k -> new HashSet<>()).add(word);
+    }
+    for (String key : diffCounter.keySet()) {
+      if (diffCounter.get(key).size() == 1) {
+        return diffCounter.get(key).iterator().next();
+      }
+    }
+    return "";
+  }
+  
+  private static String getDiffCounter(String word) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 1; i < word.length(); i++) {
+      sb.append(word.charAt(i) - word.charAt(i - 1)).append('|');
+    }
+    return sb.toString();
+  }
+}

From 781c66c7140e4615c927466671d90068c88c1499 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Oct 2022 07:09:52 -0700
Subject: [PATCH 1439/2175] Create Average Value of Even Numbers That Are
 Divisible by Three.java

---
 ...of Even Numbers That Are Divisible by Three.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Average Value of Even Numbers That Are Divisible by Three.java

diff --git a/Easy/Average Value of Even Numbers That Are Divisible by Three.java b/Easy/Average Value of Even Numbers That Are Divisible by Three.java
new file mode 100644
index 00000000..c0e3274e
--- /dev/null
+++ b/Easy/Average Value of Even Numbers That Are Divisible by Three.java	
@@ -0,0 +1,13 @@
+class Solution {
+  public int averageValue(int[] nums) {
+    int total = 0;
+    int count = 0;
+    for (int num : nums) {
+      if (num % 2 == 0 && num % 3 == 0) {
+        total += num;
+        count++;
+      }
+    }
+    return count == 0 ? 0 : total / count;
+  }
+}

From 9ea1fb1ab4c03fd65d9e6d745936c69a4d750b35 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 31 Oct 2022 08:21:08 -0700
Subject: [PATCH 1440/2175] Create Most Popular Video Creator.java

---
 Medium/Most Popular Video Creator.java | 27 ++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Most Popular Video Creator.java

diff --git a/Medium/Most Popular Video Creator.java b/Medium/Most Popular Video Creator.java
new file mode 100644
index 00000000..d9e93554
--- /dev/null
+++ b/Medium/Most Popular Video Creator.java	
@@ -0,0 +1,27 @@
+class Solution {
+  public List<List<String>> mostPopularCreator(String[] creators, String[] ids, int[] views) {
+    Map<String, Long> creatorToViewCount = new HashMap<>();
+    Map<String, Pair<String, Long>> creatorToIdWithMaxViews = new HashMap<>();
+    long totalMaxViews = 0;
+    for (int i = 0; i < creators.length; i++) {
+      creatorToViewCount.put(creators[i], creatorToViewCount.getOrDefault(creators[i], 0L) + views[i]);
+      if (!creatorToIdWithMaxViews.containsKey(creators[i])) {
+        creatorToIdWithMaxViews.put(creators[i], new Pair<>(ids[i], (long) views[i]));
+      } else {
+        Pair<String, Long> currentIdToViewPair = creatorToIdWithMaxViews.get(creators[i]);
+        if (views[i] > currentIdToViewPair.getValue() || 
+            (views[i] == currentIdToViewPair.getValue() && ids[i].compareTo(currentIdToViewPair.getKey()) < 0)) {
+          creatorToIdWithMaxViews.put(creators[i], new Pair<>(ids[i], (long) views[i]));
+        }
+      }
+      totalMaxViews = Math.max(totalMaxViews, creatorToViewCount.get(creators[i]));
+    }
+    List<List<String>> result = new ArrayList<>();
+    for (String key : creatorToViewCount.keySet()) {
+      if (creatorToViewCount.get(key) == totalMaxViews) {
+        result.add(Arrays.asList(key, creatorToIdWithMaxViews.get(key).getKey()));
+      }
+    }
+    return result;
+  }
+}

From 35b369d888bd03667297fcda4b3ee4fc5bca9877 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Nov 2022 16:41:28 -0800
Subject: [PATCH 1441/2175] Update Maximum 69 Number.java

---
 Easy/Maximum 69 Number.java | 28 ++++++++--------------------
 1 file changed, 8 insertions(+), 20 deletions(-)

diff --git a/Easy/Maximum 69 Number.java b/Easy/Maximum 69 Number.java
index a58d97e6..400bf663 100644
--- a/Easy/Maximum 69 Number.java	
+++ b/Easy/Maximum 69 Number.java	
@@ -1,23 +1,11 @@
 class Solution {
-  public int maximum69Number (int num) {
-    int lastSixIndex = Integer.MAX_VALUE;
-    int count = 0;
-    int copy = num;
-    while (copy > 0) {
-      int rem = copy % 10;
-      if (rem == 6) {
-        lastSixIndex = count;
-      }
-      copy /= 10;
-      count++;
+    public int maximum69Number (int num) {
+        String numString = String.valueOf(num);
+        for (int i = 0; i < numString.length(); i++) {
+            if (numString.charAt(i) == '6') {
+                return Integer.parseInt(numString.substring(0, i) + '9' + numString.substring(i + 1));
+            }
+        }
+        return num;
     }
-    if (lastSixIndex == Integer.MAX_VALUE) {
-      return num;
-    }
-    return (
-      ((num / ((int) Math.pow(10, lastSixIndex + 1))) * ((int) Math.pow(10, lastSixIndex + 1))) +
-      (9 * ((int) Math.pow(10, lastSixIndex))) + 
-      (num % ((int) Math.pow(10, lastSixIndex)))
-    );
-  }
 }

From 43e47ddc542ef8f39ee9a2c13bad4c87626f3df3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Nov 2022 16:45:40 -0800
Subject: [PATCH 1442/2175] Create Apply Operations to an Array.java

---
 Easy/Apply Operations to an Array.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Apply Operations to an Array.java

diff --git a/Easy/Apply Operations to an Array.java b/Easy/Apply Operations to an Array.java
new file mode 100644
index 00000000..b0a663a2
--- /dev/null
+++ b/Easy/Apply Operations to an Array.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int[] applyOperations(int[] nums) {
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] == nums[i + 1]) {
+                nums[i] *= 2;
+                nums[i + 1] = 0;
+            }
+        }
+        int startIdx = 0;
+        int endIdx = 0;
+        while (endIdx < nums.length) {
+            if (nums[endIdx] != 0) {
+                nums[startIdx++] = nums[endIdx];
+            }
+            endIdx++;
+        }
+        while (startIdx < nums.length) {
+            nums[startIdx++] = 0;
+        }
+        return nums;
+    }
+}

From 4a1ff57e93b88da09950bf8be416a299f010d0c1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Nov 2022 07:02:26 -0800
Subject: [PATCH 1443/2175] Create Maximum Sum of Distinct Subarrays With
 Length K.java

---
 ...m of Distinct Subarrays With Length K.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Maximum Sum of Distinct Subarrays With Length K.java

diff --git a/Medium/Maximum Sum of Distinct Subarrays With Length K.java b/Medium/Maximum Sum of Distinct Subarrays With Length K.java
new file mode 100644
index 00000000..044ad0bd
--- /dev/null
+++ b/Medium/Maximum Sum of Distinct Subarrays With Length K.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public long maximumSubarraySum(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        long currSum = 0;
+        long maxSum = 0;
+        for (int i = 0; i < k - 1; i++) {
+            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
+            currSum += nums[i];
+        }
+        int startIdx = 0;
+        for (int i = k - 1; i < nums.length; i++) {
+            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
+            currSum += nums[i];
+            if (map.size() == k) {
+                maxSum = Math.max(maxSum, currSum);
+            }
+            map.put(nums[startIdx], map.get(nums[startIdx]) - 1);
+            if (map.get(nums[startIdx]) == 0) {
+                map.remove(nums[startIdx]);
+            }
+            currSum -= nums[startIdx];
+            startIdx++;
+        }
+        return maxSum;
+    }
+}

From 20bc4263b07fdae17f7a1dfe6b3ce2d95370f57f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Nov 2022 08:20:05 -0800
Subject: [PATCH 1444/2175] Update Positions of Large Groups.java

---
 Easy/Positions of Large Groups.java | 37 +++++++++--------------------
 1 file changed, 11 insertions(+), 26 deletions(-)

diff --git a/Easy/Positions of Large Groups.java b/Easy/Positions of Large Groups.java
index 0e54382f..7258f529 100644
--- a/Easy/Positions of Large Groups.java	
+++ b/Easy/Positions of Large Groups.java	
@@ -1,32 +1,17 @@
 class Solution {
-    public List<List<Integer>> largeGroupPositions(String S) {
-        List<List<Integer>> positions = new ArrayList<>();
-
-        int i = 1;
-        int count = 1;
-        int start = 0;
-
-        while (i < S.length()) {
-            if (S.charAt(i) == S.charAt(i-1)) {
-                count++;
+    public List<List<Integer>> largeGroupPositions(String s) {
+        List<List<Integer>> result = new ArrayList<>();
+        int idx = 0;
+        while (idx < s.length()) {
+            int startIdx = idx;
+            char c = s.charAt(idx);
+            while (idx < s.length() && s.charAt(idx) == c) {
+                idx++;
             }
-            else {
-                if (count >= 3) {
-                    List<Integer> temp = Arrays.asList(start, i-1);
-                    positions.add(temp);
-                }
-
-                start = i;
-                count = 1;
+            if (idx - startIdx >= 3) {
+                result.add(Arrays.asList(startIdx, idx - 1));
             }
-
-            i++;
         }
-
-        if (count >= 3) {
-            positions.add(Arrays.asList(start, i-1));
-        }
-
-        return positions;
+        return result;
     }
 }

From f72e69c198d0ec8a8719e1985c73eafd87cbeda5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 8 Nov 2022 15:54:28 -0800
Subject: [PATCH 1445/2175] Update Binary Gap.java

---
 Easy/Binary Gap.java | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/Easy/Binary Gap.java b/Easy/Binary Gap.java
index c86d7908..fcd7178f 100644
--- a/Easy/Binary Gap.java	
+++ b/Easy/Binary Gap.java	
@@ -1,21 +1,19 @@
 class Solution {
-    public int binaryGap(int N) {
-        char[] binValues = Integer.toBinaryString(N).toCharArray();
-        int oneIndex = -1;
-        int maxDistance = 0;
-        
-        for (int i=0; i<binValues.length; i++) {
-            if (binValues[i] == '1') {
-                if (oneIndex == -1) {
-                    oneIndex = i;
-                }
-                else {
-                    maxDistance = Math.max(i - oneIndex, maxDistance);
-                    oneIndex = i;
+    public int binaryGap(int n) {
+        int lastOnePosition = -1;
+        int currPosition = 0;
+        int maxGap = 0;
+        while (n > 0) {
+            int rem = n % 2;
+            n /= 2;
+            if (rem == 1) {
+                if (lastOnePosition != -1) {
+                    maxGap = Math.max(maxGap, currPosition - lastOnePosition);
                 }
+                lastOnePosition = currPosition;
             }
+            currPosition++;
         }
-        
-        return maxDistance;
+        return maxGap;
     }
 }

From d6ea23e31b958b835636b35093f5d7ceac7cf381 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Nov 2022 11:45:32 -0800
Subject: [PATCH 1446/2175] Update Online Stock Span.java

---
 Medium/Online Stock Span.java | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/Medium/Online Stock Span.java b/Medium/Online Stock Span.java
index 9f30c4fd..ff50093d 100644
--- a/Medium/Online Stock Span.java	
+++ b/Medium/Online Stock Span.java	
@@ -1,21 +1,20 @@
 class StockSpanner {
-  Stack<Integer> stack;
-  Stack<Integer> occurences;
-  public StockSpanner() {
-    stack = new Stack<>();
-    occurences = new Stack<>();
-  }
-
-  public int next(int price) {
-    int count = 1;
-    while (!stack.isEmpty() && stack.peek() <= price) {
-      stack.pop();
-      count += occurences.pop();
+    
+    // Entry in stack is the current price and count of prices <= current price
+    private final Stack<int[]> stack;
+    
+    public StockSpanner() {
+        this.stack = new Stack<>();
+    }
+    
+    public int next(int price) {
+        int count = 1;
+        while (!stack.isEmpty() && stack.peek()[0] <= price) {
+            count += stack.pop()[1];
+        }
+        stack.push(new int[]{price, count});
+        return count;
     }
-    stack.push(price);
-    occurences.push(count);
-    return count;
-  }
 }
 
 /**

From 3d3df107b3fe373d33674fda17b65b0c7a7d4118 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Nov 2022 11:49:17 -0800
Subject: [PATCH 1447/2175] Create Root Equals Sum of Children.java

---
 Easy/Root Equals Sum of Children.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Root Equals Sum of Children.java

diff --git a/Easy/Root Equals Sum of Children.java b/Easy/Root Equals Sum of Children.java
new file mode 100644
index 00000000..a354dc1a
--- /dev/null
+++ b/Easy/Root Equals Sum of Children.java	
@@ -0,0 +1,20 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean checkTree(TreeNode root) {
+        return root.val == (root.left.val + root.right.val);
+    }
+}

From 8a7bbfbb07984d9102d535ff62329c14c2edcd01 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Nov 2022 16:30:49 -0800
Subject: [PATCH 1448/2175] Update Remove All Adjacent Duplicates In
 String.java

---
 ...ove All Adjacent Duplicates In String.java | 31 +++++++++----------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/Easy/Remove All Adjacent Duplicates In String.java b/Easy/Remove All Adjacent Duplicates In String.java
index 0eb0caa8..6c3a1553 100644
--- a/Easy/Remove All Adjacent Duplicates In String.java	
+++ b/Easy/Remove All Adjacent Duplicates In String.java	
@@ -1,20 +1,17 @@
 class Solution {
-  public String removeDuplicates(String s) {
-    Stack<Character> stack = new Stack<>();
-    int idx = 0;
-    while (idx < s.length()) {
-      char c = s.charAt(idx);
-      if (!stack.isEmpty() && stack.peek() == c) {
-        stack.pop();
-      } else {
-        stack.push(c);
-      }
-      idx++;
+    public String removeDuplicates(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && stack.peek() == c) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
     }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append(stack.pop());
-    }
-    return sb.reverse().toString();
-  }
 }

From d01c88489e89b4840e6765486f89f97494a45615 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Nov 2022 08:29:15 -0800
Subject: [PATCH 1449/2175] Create Tweet Counts Per Frequency.java

---
 Medium/Tweet Counts Per Frequency.java | 36 ++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 Medium/Tweet Counts Per Frequency.java

diff --git a/Medium/Tweet Counts Per Frequency.java b/Medium/Tweet Counts Per Frequency.java
new file mode 100644
index 00000000..9d58d990
--- /dev/null
+++ b/Medium/Tweet Counts Per Frequency.java	
@@ -0,0 +1,36 @@
+class TweetCounts {
+
+  private final Map<String, TreeMap<Integer, Integer>> map;
+  private static final Map<String, Integer> INTERVAL_MAP = Map.of(
+      "minute", 60,
+      "hour", 3600,
+      "day", 86400);
+
+  public TweetCounts() {
+    this.map = new HashMap<>();
+  }
+
+  public void recordTweet(String tweetName, int time) {
+    map.computeIfAbsent(tweetName, k -> new TreeMap<>());
+    map.get(tweetName).merge(time, 1, Integer::sum);
+  }
+
+  public List<Integer> getTweetCountsPerFrequency(String freq, String tweetName, int startTime, int endTime) {
+    int interval = INTERVAL_MAP.get(freq);
+    int size = ((endTime - startTime) / interval + 1);
+    int[] buckets = new int[size];
+    TreeMap<Integer, Integer> frequencyMap = map.get(tweetName);
+    for (Integer key : frequencyMap.subMap(startTime, endTime + 1).keySet()) {
+      int idx = (key - startTime) / interval;
+      buckets[idx] += frequencyMap.get(key);
+    }
+    return Arrays.stream(buckets).boxed().collect(Collectors.toList());
+  }
+}
+
+/**
+ * Your TweetCounts object will be instantiated and called as such:
+ * TweetCounts obj = new TweetCounts();
+ * obj.recordTweet(tweetName,time);
+ * List<Integer> param_2 = obj.getTweetCountsPerFrequency(freq,tweetName,startTime,endTime);
+ */

From d23cb1bda2d74c80d1191616086fad3ccbcf6385 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Nov 2022 09:36:02 -0800
Subject: [PATCH 1450/2175] Create Number of Distinct Averages.java

---
 Easy/Number of Distinct Averages.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Number of Distinct Averages.java

diff --git a/Easy/Number of Distinct Averages.java b/Easy/Number of Distinct Averages.java
new file mode 100644
index 00000000..cb2f9b34
--- /dev/null
+++ b/Easy/Number of Distinct Averages.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int distinctAverages(int[] nums) {
+        Arrays.sort(nums);
+        Set<Double> averages = new HashSet<>();
+        int startIdx = 0;
+        int endIdx = nums.length - 1;
+        while (startIdx <= endIdx) {
+            double total = (double) (nums[startIdx++] + nums[endIdx--]);
+            averages.add(total / 2);
+        }
+        return averages.size();
+    }
+}

From 3dae145fa05247256b6a6d2228d25b2ade1b4cab Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Nov 2022 15:31:55 -0800
Subject: [PATCH 1451/2175] Update Find Median from Data Stream.java

---
 Hard/Find Median from Data Stream.java | 41 +++++++++++++-------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/Hard/Find Median from Data Stream.java b/Hard/Find Median from Data Stream.java
index 7d0de21f..89269294 100644
--- a/Hard/Find Median from Data Stream.java	
+++ b/Hard/Find Median from Data Stream.java	
@@ -1,27 +1,26 @@
 class MedianFinder {
-
-  private PriorityQueue<Integer> small;
-  private PriorityQueue<Integer> large;
-  
-  public MedianFinder() {
-    this.small = new PriorityQueue<>((a, b) -> b - a);
-    this.large = new PriorityQueue<>();
-  }
-
-  public void addNum(int num) {
-    small.add(num);
-    large.add(small.remove());
-    if (large.size() > small.size()) {
-      small.add(large.remove());
+    
+    private final PriorityQueue<Integer> minQueue;
+    private final PriorityQueue<Integer> maxQueue;
+    
+    public MedianFinder() {
+        this.minQueue = new PriorityQueue<>();
+        this.maxQueue = new PriorityQueue<>((a, b) -> b - a);
     }
-  }
-
-  public double findMedian() {
-    if (small.size() > large.size()) {
-      return small.peek();
+    
+    public void addNum(int num) {
+        maxQueue.add(num);
+        minQueue.add(maxQueue.poll());
+        if (maxQueue.size() < minQueue.size()) {
+            maxQueue.add(minQueue.poll());
+        }
+    }
+    
+    public double findMedian() {
+        return maxQueue.size() > minQueue.size() ? 
+            ((double) maxQueue.peek()) : 
+            ((maxQueue.peek() + minQueue.peek()) / (2.0));
     }
-    return (small.peek() + large.peek()) / 2.0;
-  }
 }
 
 /**

From 04c87abe28bd81873938b81cdaf3569305d13988 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Nov 2022 06:54:21 -0800
Subject: [PATCH 1452/2175] Update Reverse Words in a String.java

---
 Medium/Reverse Words in a String.java | 59 +++++++--------------------
 1 file changed, 14 insertions(+), 45 deletions(-)

diff --git a/Medium/Reverse Words in a String.java b/Medium/Reverse Words in a String.java
index 4d70c9e9..94076a54 100644
--- a/Medium/Reverse Words in a String.java	
+++ b/Medium/Reverse Words in a String.java	
@@ -1,49 +1,18 @@
 class Solution {
-  public String reverseWords(String s) {
-    StringBuilder sb = trimSpace(s);
-    reverse(sb, 0, sb.length() - 1);
-    int start = 0;
-    int end = 0;
-    int n = sb.length();
-    while (start < n) {
-      while (end < n && sb.charAt(end) != ' ') {
-        end++;
-      }
-      reverse(sb, start, end - 1);
-      start = end + 1;
-      end++;
-    }
-    return sb.toString();
-  }
-  
-  private void reverse(StringBuilder sb, int start, int end) {
-    while (start <= end) {
-      char temp = sb.charAt(start);
-      sb.setCharAt(start++, sb.charAt(end));
-      sb.setCharAt(end--, temp);
-    }
-  }
-  
-  private StringBuilder trimSpace(String s) {
-    StringBuilder sb = new StringBuilder();
-    int start = 0;
-    int end = s.length() - 1;
-    while (start <= end && s.charAt(start) == ' ') {
-      start++;
-    }
-    while (end >= start && s.charAt(end) == ' ') {
-      end--;
-    }
-    while (start <= end) {
-      if (s.charAt(start) != ' ') {
-        sb.append(s.charAt(start++));
-      } else {
-        if (sb.charAt(sb.length() - 1) != ' ') {
-          sb.append(s.charAt(start));
+    public String reverseWords(String s) {
+        StringBuilder result = new StringBuilder();
+        int idx = s.length() - 1;
+        while (idx >= 0) {
+            if (s.charAt(idx) == ' ') {
+                idx--;
+                continue;
+            }
+            StringBuilder sb = new StringBuilder();
+            while (idx >= 0 && Character.isLetterOrDigit(s.charAt(idx))) {
+                sb.append(s.charAt(idx--));
+            }
+            result.append(sb.reverse().toString()).append(" ");
         }
-        start++;
-      }
+        return result.toString().trim();
     }
-    return sb;
-  }
 }

From 0ce46d4114641e78c4ef9e6e411e191e8599f529 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 14 Nov 2022 06:50:12 -0800
Subject: [PATCH 1453/2175] Create Convert the Temperature.java

---
 Easy/Convert the Temperature.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Convert the Temperature.java

diff --git a/Easy/Convert the Temperature.java b/Easy/Convert the Temperature.java
new file mode 100644
index 00000000..0b1f250c
--- /dev/null
+++ b/Easy/Convert the Temperature.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public double[] convertTemperature(double celsius) {
+        return new double[]{/* kelvin= */celsius + 273.15, /* fahrenheit= */celsius * 1.80 + 32.00};
+    }
+}

From 5126b747b9e93349f0331d9b566decc819e96415 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Nov 2022 07:33:18 -0800
Subject: [PATCH 1454/2175] Update Count Complete Tree Nodes.java

---
 Medium/Count Complete Tree Nodes.java | 74 ++++++++++-----------------
 1 file changed, 26 insertions(+), 48 deletions(-)

diff --git a/Medium/Count Complete Tree Nodes.java b/Medium/Count Complete Tree Nodes.java
index 8c4bd90f..822c178d 100644
--- a/Medium/Count Complete Tree Nodes.java	
+++ b/Medium/Count Complete Tree Nodes.java	
@@ -4,57 +4,35 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  public int countNodes(TreeNode root) {
-    if (root == null) {
-      return 0;
+    public int countNodes(TreeNode root) {
+        int leftDepth = getDepth(root, -1);
+        int rightDepth = getDepth(root, 1);
+        if (leftDepth == rightDepth) {
+            return (1 << leftDepth) - 1;
+        }
+        return 1 + countNodes(root.left) + countNodes(root.right);
     }
-    int d = getDepth(root);
-    if (d == 0) {
-      return 1;
+    
+    private int getDepth(TreeNode root, int dir) {
+        int depth = 0;
+        while (root != null) {
+            depth++;
+            if (dir == -1) {
+                root =  root.left;
+            } else {
+                root = root.right;
+            }
+        }
+        return depth;
     }
-    int start = 0;
-    int end = (int) Math.pow(2, d) - 1;
-    int mid;
-    while (start <= end) {
-      mid = start + (end - start) / 2;
-      if (exists(mid, d, root)) {
-        start = mid + 1;
-      }
-      else {
-        end = mid - 1;
-      }
-    }
-    return (int) Math.pow(2, d) - 1 + start;
-  }
-  
-  private int getDepth(TreeNode node) {
-    int d = 0;
-    while (node.left != null) {
-      node = node.left;
-      d++;
-    }
-    return d;
-  }
-  
-  private boolean exists(int idx, int d, TreeNode root) {
-    int left = 0;
-    int right = (int) Math.pow(2, d) - 1;
-    int mid;
-    for(int i = 0; i < d; ++i) {
-      mid = left + (right - left) / 2;
-      if (idx <= mid) {
-        root = root.left;
-        right = mid;
-      }
-      else {
-        root = root.right;
-        left = mid + 1;
-      }
-    }
-    return root != null;
-  }
 }

From 637c0ecfd4d11bde127743b999dd406ed22b4a62 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Nov 2022 08:47:13 -0800
Subject: [PATCH 1455/2175] Create Number of Unequal Triplets in Array.java

---
 Easy/Number of Unequal Triplets in Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Number of Unequal Triplets in Array.java

diff --git a/Easy/Number of Unequal Triplets in Array.java b/Easy/Number of Unequal Triplets in Array.java
new file mode 100644
index 00000000..fc2fa82a
--- /dev/null
+++ b/Easy/Number of Unequal Triplets in Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int unequalTriplets(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        int result = 0;
+        int left = 0;
+        int right = nums.length;
+        for (Integer key : map.keySet()) {
+            right -= map.get(key);
+            result += left * map.get(key) * right;
+            left += map.get(key);
+        }
+        return result;
+    }
+}

From 1812e49c10a7c06621751a4d71cadfce8858bd8e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Nov 2022 08:54:46 -0800
Subject: [PATCH 1456/2175] Create Closest Nodes Queries in a Binary Search
 Tree.java

---
 ...Nodes Queries in a Binary Search Tree.java | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/Closest Nodes Queries in a Binary Search Tree.java

diff --git a/Medium/Closest Nodes Queries in a Binary Search Tree.java b/Medium/Closest Nodes Queries in a Binary Search Tree.java
new file mode 100644
index 00000000..e1c19211
--- /dev/null
+++ b/Medium/Closest Nodes Queries in a Binary Search Tree.java	
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> closestNodes(TreeNode root, List<Integer> queries) {
+        TreeSet<Integer> set = new TreeSet<>();
+        traverse(root, set);
+        List<List<Integer>> result = new ArrayList<>();
+        for (Integer query : queries) {
+            Integer lower = set.floor(query);
+            Integer upper = set.ceiling(query);
+            result.add(Arrays.asList((lower == null ? -1 : lower), (upper == null ? -1 : upper)));
+        }
+        return result;
+    }
+    
+    private void traverse(TreeNode root, TreeSet<Integer> set) {
+        if (root == null) {
+            return;
+        }
+        set.add(root.val);
+        traverse(root.left, set);
+        traverse(root.right, set);
+    }
+}

From ae399d8f768df2383ec59aba4a00df2e6e8dd616 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Nov 2022 08:05:53 -0800
Subject: [PATCH 1457/2175] Create Nearest Exit from Entrance in Maze.java

---
 .../Nearest Exit from Entrance in Maze.java   | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 Medium/Nearest Exit from Entrance in Maze.java

diff --git a/Medium/Nearest Exit from Entrance in Maze.java b/Medium/Nearest Exit from Entrance in Maze.java
new file mode 100644
index 00000000..097d5aaa
--- /dev/null
+++ b/Medium/Nearest Exit from Entrance in Maze.java	
@@ -0,0 +1,45 @@
+class Solution {
+    private static final int[][] DIRS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+    
+    public int nearestExit(char[][] maze, int[] entrance) {
+        int rows = maze.length;
+        int cols = maze[0].length;
+        Queue<int[]> queue = new LinkedList<>();
+        boolean[][] visited = new boolean[rows][cols];
+        int entranceRow = entrance[0];
+        int entranceCol = entrance[1];
+        queue.add(new int[]{entranceRow, entranceCol});
+        visited[entranceRow][entranceCol] = true;
+        int steps = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                int row = removed[0];
+                int col = removed[1];
+                if (!(row == entranceRow && col == entranceCol) && isExit(row, col, rows, cols)) {
+                    return steps;
+                }
+                for (int[] dir : DIRS) {
+                    int newRow = row + dir[0];
+                    int newCol = col + dir[1];
+                    if (newRow >= 0 && 
+                        newCol >= 0 && 
+                        newRow < rows && 
+                        newCol < cols && 
+                        !visited[newRow][newCol] &&
+                        maze[newRow][newCol] != '+') {
+                        queue.add(new int[]{newRow, newCol});
+                        visited[newRow][newCol] = true;
+                    }
+                }
+            }
+            steps++;
+        }
+        return -1;
+    }
+    
+    private boolean isExit(int row, int col, int rows, int cols) {
+        return (row + 1 == rows) || (row - 1 == -1) || (col + 1 == cols) || (col - 1 == -1);
+    }
+}

From 03349e814400e7424baa08800e48776c0712612c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 23 Nov 2022 10:08:28 -0800
Subject: [PATCH 1458/2175] Create Check if an Array Is Consecutive.java

---
 Easy/Check if an Array Is Consecutive.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Check if an Array Is Consecutive.java

diff --git a/Easy/Check if an Array Is Consecutive.java b/Easy/Check if an Array Is Consecutive.java
new file mode 100644
index 00000000..618d43e6
--- /dev/null
+++ b/Easy/Check if an Array Is Consecutive.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public boolean isConsecutive(int[] nums) {
+        int min = Integer.MAX_VALUE;
+        for (int num : nums) {
+            min = Math.min(num, min);
+        }
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            if (num - min >= nums.length || !set.add(num - min)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From 563ba954dbc3b26098553f86d33d670736748635 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 24 Nov 2022 07:50:33 -0800
Subject: [PATCH 1459/2175] Update Word Search.java

---
 Medium/Word Search.java | 57 ++++++++++++++++++++---------------------
 1 file changed, 28 insertions(+), 29 deletions(-)

diff --git a/Medium/Word Search.java b/Medium/Word Search.java
index b5dc90c4..5a63db20 100644
--- a/Medium/Word Search.java	
+++ b/Medium/Word Search.java	
@@ -1,34 +1,33 @@
 class Solution {
-  
-  private final int[][] DIRS = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
-  
-  public boolean exist(char[][] board, String word) {
-    int m = board.length;
-    int n = board[0].length;
-    for (int i = 0; i < board.length; i++) {
-      for (int j = 0; j < board[0].length; j++) {
-        if (found(board, i, j, word, 0, m, n)) {
-          return true;
+    
+    private static final int[][] DIRS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+    
+    public boolean exist(char[][] board, String word) {
+        int m = board.length;
+        int n = board[0].length;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (isFound(board, word, 0, i, j, m, n)) {
+                    return true;
+                }
+            }
         }
-      }
+        return false;
     }
-    return false;
-  }
-  
-  private boolean found(char[][] board, int x, int y, String word, int idx, int m, int n) {
-    if (idx == word.length()) {
-      return true;
-    }
-    if (x < 0 || x == m || y < 0 || y == n || board[x][y] != word.charAt(idx)) {
-      return false;
-    }
-    board[x][y] = '#';
-    for (int[] dir : DIRS) {
-      if (found(board, x + dir[0], y + dir[1], word, idx + 1, m, n)) {
-        return true;
-      }
+    
+    private boolean isFound(char[][] board, String word, int idx, int row, int col, int m, int n) {
+        if (idx == word.length()) {
+            return true;
+        }
+        if (row < 0 || col < 0 || row >= m || col >= n || board[row][col] != word.charAt(idx)) {
+            return false;
+        }
+        board[row][col] ^= 256;
+        boolean result = false;
+        for (int[] dir : DIRS) {
+            result = result || isFound(board, word, idx + 1, row + dir[0], col + dir[1], m, n);
+        }
+        board[row][col] ^= 256;
+        return result;
     }
-    board[x][y] = word.charAt(idx);
-    return false;
-  }
 }

From 5630843a2267978f32010c6e932463b95d5ee920 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 25 Nov 2022 08:55:59 -0800
Subject: [PATCH 1460/2175] Create Sum of Subarray Minimums.java

---
 Medium/Sum of Subarray Minimums.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Sum of Subarray Minimums.java

diff --git a/Medium/Sum of Subarray Minimums.java b/Medium/Sum of Subarray Minimums.java
new file mode 100644
index 00000000..942f0c91
--- /dev/null
+++ b/Medium/Sum of Subarray Minimums.java	
@@ -0,0 +1,20 @@
+class Solution {
+    
+    private final static int MOD = 1000_000_007;
+    
+    public int sumSubarrayMins(int[] arr) {
+        Stack<Integer> stack = new Stack<>();
+        long sum = 0;
+        for (int i = 0; i <= arr.length; i++) {
+            while (!stack.isEmpty() && (i == arr.length || arr[stack.peek()] >= arr[i])) {
+                int minValue = stack.pop();
+                int countOnLeft = stack.empty() ? -1 : stack.peek();
+                int countOnRight = i;
+                long totalCount = (minValue - countOnLeft) * (countOnRight - minValue) % MOD;
+                sum = (sum + (totalCount * arr[minValue])) % MOD;
+            }
+            stack.push(i);
+        }
+        return (int) (sum);
+    }
+}

From 264bbb46899a1b314b9598267c56fbc9dd6e2e5c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 25 Nov 2022 17:54:23 -0800
Subject: [PATCH 1461/2175] Create Check if String Is Decomposable Into
 Value-Equal Substrings.java

---
 ...omposable Into Value-Equal Substrings.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Check if String Is Decomposable Into Value-Equal Substrings.java

diff --git a/Easy/Check if String Is Decomposable Into Value-Equal Substrings.java b/Easy/Check if String Is Decomposable Into Value-Equal Substrings.java
new file mode 100644
index 00000000..6d6d55c4
--- /dev/null
+++ b/Easy/Check if String Is Decomposable Into Value-Equal Substrings.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public boolean isDecomposable(String s) {
+        boolean sizeTwoFound = false;
+        int idx = 0;
+        while (idx < s.length()) {
+            char c = s.charAt(idx);
+            int tempIdx = idx;
+            while (tempIdx < s.length() && s.charAt(tempIdx) == c && tempIdx - idx < 3) {
+                tempIdx++;
+            }
+            int occurrences = tempIdx - idx;
+            if (occurrences < 2) {
+                return false;
+            }
+            if (occurrences == 2) {
+                if (sizeTwoFound) {
+                    return false;
+                }
+                sizeTwoFound = true;
+            }
+            idx = tempIdx;
+        }
+        return sizeTwoFound;
+    }       
+}

From e6f524172f779bbc7c26b65c6d9397110432c575 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Nov 2022 15:38:41 -0800
Subject: [PATCH 1462/2175] Create Maximum Profit in Job Scheduling.java

---
 Hard/Maximum Profit in Job Scheduling.java | 28 ++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Hard/Maximum Profit in Job Scheduling.java

diff --git a/Hard/Maximum Profit in Job Scheduling.java b/Hard/Maximum Profit in Job Scheduling.java
new file mode 100644
index 00000000..f95e58ab
--- /dev/null
+++ b/Hard/Maximum Profit in Job Scheduling.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
+        int n = startTime.length;
+        int[][] jobs = new int[n][3];
+        for (int i = 0; i < n; i++) {
+            jobs[i] = new int[]{startTime[i], endTime[i], profit[i]};
+        }
+        Arrays.sort(jobs, (a, b) -> a[0] - b[0]);
+        Integer[] cache = new Integer[n];
+        return dfs(0, jobs, cache);
+    }
+    
+    private int dfs(int idx, int[][] jobs, Integer[] cache) {
+        if (idx == jobs.length) {
+            return 0;
+        }
+        if (cache[idx] != null) {
+            return cache[idx];
+        }
+        int nextIdx = idx + 1;
+        while (nextIdx < jobs.length && jobs[idx][1] > jobs[nextIdx][0]) {
+            nextIdx++;
+        }
+        int jobScheduled = jobs[idx][2] + dfs(nextIdx, jobs, cache);
+        int jobNotScheduled = dfs(idx + 1, jobs, cache);
+        return cache[idx] = Math.max(jobScheduled, jobNotScheduled);
+    }
+}

From 15b90757530a1a4ad64f74a23a63e6e25b7375e6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Nov 2022 18:27:56 -0800
Subject: [PATCH 1463/2175] Create Minimum Cuts to Divide a Circle.java

---
 Easy/Minimum Cuts to Divide a Circle.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Minimum Cuts to Divide a Circle.java

diff --git a/Easy/Minimum Cuts to Divide a Circle.java b/Easy/Minimum Cuts to Divide a Circle.java
new file mode 100644
index 00000000..16540797
--- /dev/null
+++ b/Easy/Minimum Cuts to Divide a Circle.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int numberOfCuts(int n) {
+        return n == 1 ? 0 : (n % 2 == 0 ? n / 2 : n);
+    }
+}

From df0a087491cd52a1f0cfec5e22ef09a135d8ea83 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Nov 2022 07:57:29 -0800
Subject: [PATCH 1464/2175] Create Append Characters to String to Make
 Subsequence.java

---
 ...nd Characters to String to Make Subsequence.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Append Characters to String to Make Subsequence.java

diff --git a/Medium/Append Characters to String to Make Subsequence.java b/Medium/Append Characters to String to Make Subsequence.java
new file mode 100644
index 00000000..af35ca3d
--- /dev/null
+++ b/Medium/Append Characters to String to Make Subsequence.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int appendCharacters(String s, String t) {
+        int idxS = 0;
+        int idxT = 0;
+        while (idxS < s.length() && idxT < t.length()) {
+            if (s.charAt(idxS) == t.charAt(idxT)) {
+                idxT++;
+            }
+            idxS++;
+        }
+        return idxT == t.length() ? 0 : t.length() - idxT;
+    }
+}

From cbe46171937d1765f96c60fff58e4c143c9b2f52 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Nov 2022 17:45:33 -0800
Subject: [PATCH 1465/2175] Create Remove Nodes From Linked List.java

---
 Medium/Remove Nodes From Linked List.java | 40 +++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 Medium/Remove Nodes From Linked List.java

diff --git a/Medium/Remove Nodes From Linked List.java b/Medium/Remove Nodes From Linked List.java
new file mode 100644
index 00000000..850e4da0
--- /dev/null
+++ b/Medium/Remove Nodes From Linked List.java	
@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeNodes(ListNode head) {
+        ListNode revNode = reverse(head);
+        ListNode curr = revNode;
+        ListNode prev = null;
+        int maxValue = Integer.MIN_VALUE;
+        while (curr != null) {
+            if (curr.val < maxValue) {
+                prev.next = curr.next;
+            } else {
+                prev = curr;
+                maxValue = Math.max(curr.val, maxValue);
+            }
+            curr = curr.next;
+        }
+        return reverse(revNode);
+    }
+    
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
+    }
+}

From 9bb3ac3b04c648b30d94067e777f2cd3351e992d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Nov 2022 07:04:59 -0800
Subject: [PATCH 1466/2175] Update Design Snake Game.java

---
 Medium/Design Snake Game.java | 137 +++++++++++++++-------------------
 1 file changed, 62 insertions(+), 75 deletions(-)

diff --git a/Medium/Design Snake Game.java b/Medium/Design Snake Game.java
index e4185474..dd645d15 100644
--- a/Medium/Design Snake Game.java	
+++ b/Medium/Design Snake Game.java	
@@ -1,87 +1,74 @@
 class SnakeGame {
-  
-  private final int width;
-  private final int height;
-  private final Set<Pair<Integer, Integer>> body;
-  private final Deque<Pair<Integer, Integer>> bodyQueue;
-  private final Queue<Pair<Integer, Integer>> foodQueue;
-  private int foodPoint;
-
-  public SnakeGame(int width, int height, int[][] food) {
-    this.width = width;
-    this.height = height;
-    this.body = new HashSet<>();
-    this.bodyQueue = new LinkedList<>();
-    this.body.add(new Pair<Integer, Integer>(0, 0));
-    this.bodyQueue.add(new Pair<Integer, Integer>(0, 0));
     
-    this.foodQueue = new LinkedList<>();
-    for (int[] fd : food) {
-      foodQueue.add(new Pair<Integer, Integer>(fd[0], fd[1]));
+    private final Deque<int[]> snake;
+    private final Queue<int[]> foodQueue;
+    private final Set<String> snakeBody;
+    private final int width;
+    private final int height;
+    private int score;
+    
+    public SnakeGame(int width, int height, int[][] food) {
+        this.snake = new ArrayDeque<>();
+        this.snake.addFirst(new int[]{0, 0});
+        this.foodQueue = new LinkedList<>();
+        this.foodQueue.addAll(Arrays.asList(food));
+        this.snakeBody = new HashSet<>();
+        this.snakeBody.add(0 + "|" + 0);
+        this.width = width;
+        this.height = height;
+        this.score = 0;
     }
-    this.foodPoint = 0;
-  }
-
-  public int move(String direction) {
-    Pair<Integer, Integer> currPosition = bodyQueue.peekLast();
-    Pair<Integer, Integer> nextPosition = move(currPosition, direction);
-    if (!isSnakeAlive(nextPosition)) {
-      return -1;
+    
+    public int move(String direction) {
+        int[] nextMove = getNextMove(direction);
+        if (!isMoveWithInBound(nextMove)) {
+            return -1;
+        }
+        moveSnake(nextMove);
+        if (isBitingItself(nextMove)) {
+            return -1;
+        }
+        this.snakeBody.add(nextMove[0] + "|" + nextMove[1]);
+        return score;
     }
-    if (!snakeAteFood(nextPosition)) {
-      body.remove(bodyQueue.pollFirst());
-      bodyQueue.addLast(nextPosition);
-      body.add(nextPosition);
+    
+    private int[] getNextMove(String direction) {
+        int[] nextMove = Arrays.copyOf(this.snake.peekFirst(), 2);
+        switch (direction) {
+            case "L" -> nextMove[1]--;
+            case "R" -> nextMove[1]++;
+            case "U" -> nextMove[0]--;
+            case "D" -> nextMove[0]++;
+            default -> {}
+        }
+        return nextMove;
     }
-    return foodPoint;
-  }
-  
-  private Pair<Integer, Integer> move(Pair<Integer, Integer> currPosition, String direction) {
-    int row = currPosition.getKey();
-    int col = currPosition.getValue();
-    switch (direction) {
-      case "U":
-        row--;
-        break;
-      case "D":
-        row++;
-        break;
-      case "L":
-        col--;
-        break;
-      case "R":
-        col++;
-        break;
-      default:
-        break;
+    
+    private boolean isMoveWithInBound(int[] move) {
+        int x = move[0];
+        int y = move[1];
+        return x >= 0 && y >= 0 && x < this.height && y < this.width;
     }
-    return new Pair<Integer, Integer>(row, col);
-  }
-  
-  private boolean isSnakeAlive(Pair<Integer, Integer> position) {
-    int row = position.getKey();
-    int col = position.getValue();
-    // Snake touched the boundary
-    if (!(row >= 0 && col >= 0 && row < height && col < width)) {
-      return false;
+    
+    private void moveSnake(int[] move) {
+        this.snake.addFirst(move);
+        if (snakeEatsFood(move)) {
+            this.foodQueue.remove();
+            this.score++;
+        } else {
+            int[] tail = this.snake.removeLast();
+            this.snakeBody.remove(tail[0] + "|" + tail[1]);
+        }
     }
-    // Snake bit somewhere in middle of the body
-    if (!position.equals(this.bodyQueue.peekFirst()) && this.body.contains(position)) {
-      return false;
+    
+    private boolean snakeEatsFood(int[] move) {
+        return !this.foodQueue.isEmpty() && move[0] == this.foodQueue.peek()[0] && move[1] == this.foodQueue.peek()[1];
     }
-    return true;
-  }
-  
-  private boolean snakeAteFood(Pair<Integer, Integer> position) {
-    if (!foodQueue.isEmpty() && position.equals(foodQueue.peek())) {
-      bodyQueue.addLast(position);
-      body.add(position);
-      foodQueue.poll();
-      foodPoint++;
-      return true;
+    
+    private boolean isBitingItself(int[] move) {
+        String key = move[0] + "|" + move[1];
+        return this.snakeBody.contains(key);
     }
-    return false;
-  }
 }
 
 /**

From 34ebf07124878e5a55181ef53d014a7b785abf81 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Nov 2022 07:49:06 -0800
Subject: [PATCH 1467/2175] Create Design SQL.java

---
 Medium/Design SQL.java | 47 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 Medium/Design SQL.java

diff --git a/Medium/Design SQL.java b/Medium/Design SQL.java
new file mode 100644
index 00000000..644009b1
--- /dev/null
+++ b/Medium/Design SQL.java	
@@ -0,0 +1,47 @@
+class SQL {
+    
+    private final Map<String, Map<Integer, List<String>>> database;
+    private final Map<String, Integer> tableIdMap;
+
+    public SQL(List<String> tableNames, List<Integer> columns) {
+        this.database = new HashMap<>();
+        this.tableIdMap = new HashMap<>();
+        for (String name : tableNames) {
+            database.put(name, new HashMap<>());
+            tableIdMap.put(name, 1);
+        }
+    }
+    
+    public void insertRow(String tableName, List<String> row) {
+        // Select the table
+        Map<Integer, List<String>> table = this.database.get(tableName);
+        // Insert row in the table
+        table.put(tableIdMap.get(tableName), row);
+        // Increment rowId for the table
+        tableIdMap.put(tableName, tableIdMap.get(tableName) + 1);
+    }
+    
+    public void deleteRow(String tableName, int rowId) {
+        // Select the table
+        Map<Integer, List<String>> table = this.database.get(tableName);
+        // Delete the row against the rowId
+        table.remove(rowId);
+    }
+    
+    public String selectCell(String tableName, int rowId, int columnId) {
+        // Select the table
+        Map<Integer, List<String>> table = this.database.get(tableName);
+        // Select row
+        List<String> row = table.get(rowId);
+        // Select column
+        return row.get(columnId - 1);
+    }
+}
+
+/**
+ * Your SQL object will be instantiated and called as such:
+ * SQL obj = new SQL(names, columns);
+ * obj.insertRow(name,row);
+ * obj.deleteRow(name,rowId);
+ * String param_3 = obj.selectCell(name,rowId,columnId);
+ */

From f1a24c0311d138b2efa37d8169e2230c4b902c10 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 30 Nov 2022 08:17:24 -0800
Subject: [PATCH 1468/2175] Update Implement Trie II (Prefix Tree).java

---
 Medium/Implement Trie II (Prefix Tree).java | 110 ++++++++------------
 1 file changed, 46 insertions(+), 64 deletions(-)

diff --git a/Medium/Implement Trie II (Prefix Tree).java b/Medium/Implement Trie II (Prefix Tree).java
index e6bae27d..a3bddf29 100644
--- a/Medium/Implement Trie II (Prefix Tree).java	
+++ b/Medium/Implement Trie II (Prefix Tree).java	
@@ -1,82 +1,64 @@
-class Trie {
+public class Trie {
 
-  private Node head;
+    private final TrieNode root;
 
-  public Trie() {
-    this.head = new Node('-');
-  }
-
-  public void insert(String word) {
-    Node curr = this.head;
-    for (char c : word.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        curr.children.put(c, new Node(c));
-      }
-      curr = curr.children.get(c);
+    public Trie() {
+        this.root = new TrieNode();
     }
-    curr.wordToFrequency.put(word, curr.wordToFrequency.getOrDefault(word, 0) + 1);
-  }
 
-  public int countWordsEqualTo(String word) {
-    Node curr = this.head;
-    curr = traverseTrie(curr, word);
-    if (curr == null) {
-      return 0;
+    public void insert(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                curr.children.put(c, new TrieNode());
+            }
+            curr = curr.children.get(c);
+            curr.startingWordCount++;
+        }
+        curr.completeWordCount++;
     }
-    return curr.wordToFrequency.getOrDefault(word, 0);
-  }
 
-  public int countWordsStartingWith(String prefix) {
-    Node curr = this.head;
-    curr = traverseTrie(curr, prefix);
-    if (curr == null) {
-      return 0;
+    public int countWordsEqualTo(String word) {
+        TrieNode endNode = searchWord(word);
+        return endNode == null ? 0 : endNode.completeWordCount;
     }
-    int count = 0;
-    Queue<Node> queue = new LinkedList<>();
-    queue.add(curr);
-    while (!queue.isEmpty()) {
-      Node removed = queue.remove();
-      for (String word : removed.wordToFrequency.keySet()) {
-        count += removed.wordToFrequency.get(word);
-      }
-      for (Character child : removed.children.keySet()) {
-        queue.add(removed.children.get(child));
-      }
+
+    public int countWordsStartingWith(String prefix) {
+        TrieNode endNode = searchWord(prefix);
+        return endNode == null ? 0 : endNode.startingWordCount;
     }
-    return count;
-  }
 
-  public void erase(String word) {
-    Node curr = this.head;
-    curr = traverseTrie(curr, word);
-    if (curr == null || curr.wordToFrequency.getOrDefault(word, 0) == 0) {
-      return;
+    public void erase(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            curr = curr.children.get(c);
+            curr.startingWordCount--;
+        }
+        curr.completeWordCount--;
     }
-    curr.wordToFrequency.put(word, curr.wordToFrequency.get(word) - 1);
-  }
 
-  private Node traverseTrie(Node curr, String word) {
-    for (char c : word.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        return null;
-      }
-      curr = curr.children.get(c);
+    private TrieNode searchWord(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                return null;
+            }
+            curr = curr.children.get(c);
+        }
+        return curr;
     }
-    return curr;
-  }
 
-  private static class Node {
-    char c;
-    Map<Character, Node> children;
-    Map<String, Integer> wordToFrequency;
+    private static class TrieNode {
+        Map<Character, TrieNode> children;
+        int completeWordCount;
+        int startingWordCount;
 
-    public Node(char c) {
-      this.c = c;
-      this.children = new HashMap<>();
-      this.wordToFrequency = new HashMap<>();
+        public TrieNode() {
+            this.children = new HashMap<>();
+            this.completeWordCount = 0;
+            this.startingWordCount = 0;
+        }
     }
-  }
 }
 
 /**

From 6d24d46dd60184c7eb523490bf7a9f91b76a997d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 30 Nov 2022 13:56:53 -0800
Subject: [PATCH 1469/2175] Update Serialize and Deserialize BST.java

---
 Medium/Serialize and Deserialize BST.java | 70 +++++++++++------------
 1 file changed, 33 insertions(+), 37 deletions(-)

diff --git a/Medium/Serialize and Deserialize BST.java b/Medium/Serialize and Deserialize BST.java
index ff587f9d..a6da4bff 100644
--- a/Medium/Serialize and Deserialize BST.java	
+++ b/Medium/Serialize and Deserialize BST.java	
@@ -10,48 +10,44 @@
 public class Codec {
 
     // Encodes a tree to a single string.
-  public String serialize(TreeNode root) {
-    if (root == null) {
-      return "";
+    public String serialize(TreeNode root) {
+        if (root == null) {
+            return "#";
+        }
+        StringBuilder sb = new StringBuilder();
+        dfsSerialize(root, sb);
+        return sb.toString().trim();
     }
-    StringBuilder sb = new StringBuilder();
-    dfs(root, sb);
-    return sb.toString().trim();
-  }
-  
-  private void dfs(TreeNode root, StringBuilder sb) {
-    if (root == null) {
-      return;
+    
+    private void dfsSerialize(TreeNode root, StringBuilder sb) {
+        if (root == null) {
+            sb.append("#").append(" ");
+            return;
+        }
+        sb.append(root.val).append(" ");
+        dfsSerialize(root.left, sb);
+        dfsSerialize(root.right, sb);
     }
-    sb.append(root.val).append(" ");
-    dfs(root.left, sb);
-    dfs(root.right, sb);
-  }
 
-  // Decodes your encoded data to tree.
-  public TreeNode deserialize(String data) {
-    if (data.length() == 0) {
-      return null;
+    // Decodes your encoded data to tree.
+    public TreeNode deserialize(String data) {
+        Queue<String> queue = new LinkedList<>(Arrays.asList(data.split("\\s+")));
+        return dfsDeserialize(queue);
     }
-    String[] split = data.split("\\s+");
-    return buildBST(split, 0, split.length - 1);
-  }
-  
-  private TreeNode buildBST(String[] data, int start, int end) {
-    if (start > end) {
-      return null;
+    
+    private TreeNode dfsDeserialize(Queue<String> queue) {
+        if (queue.isEmpty()) {
+            return null;
+        }
+        String removed = queue.remove();
+        if (removed.equals("#")) {
+            return null;
+        }
+        TreeNode root = new TreeNode(Integer.parseInt(removed));
+        root.left = dfsDeserialize(queue);
+        root.right = dfsDeserialize(queue);
+        return root;
     }
-    TreeNode root = new TreeNode(Integer.parseInt(data[start]));
-    int index;
-    for (index = start; index <= end; index++) {
-      if (Integer.parseInt(data[index]) > Integer.parseInt(data[start])) {
-        break;
-      }
-    }
-    root.left = buildBST(data, start + 1, index - 1);
-    root.right = buildBST(data, index, end);
-    return root;
-  }
 }
 
 // Your Codec object will be instantiated and called as such:

From 2aaa32060b5eed2a459b110c4e1468c2c244c11e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 2 Dec 2022 07:12:27 -0800
Subject: [PATCH 1470/2175] Update Minimize Product Sum of Two Arrays.java

---
 .../Minimize Product Sum of Two Arrays.java   | 48 +++++++++----------
 1 file changed, 22 insertions(+), 26 deletions(-)

diff --git a/Medium/Minimize Product Sum of Two Arrays.java b/Medium/Minimize Product Sum of Two Arrays.java
index 4f8e184b..8302c68e 100644
--- a/Medium/Minimize Product Sum of Two Arrays.java	
+++ b/Medium/Minimize Product Sum of Two Arrays.java	
@@ -1,29 +1,25 @@
 class Solution {
-  public int minProductSum(int[] nums1, int[] nums2) {
-    int[] frequencyOne = new int[101];
-    int[] frequencyTwo = new int[101];
-    for (int i = 0; i < nums1.length; i++) {
-      frequencyOne[nums1[i]]++;
-      frequencyTwo[nums2[i]]++;
+    public int minProductSum(int[] nums1, int[] nums2) {
+        int[] frequencyOne = new int[101];
+        int[] frequencyTwo = new int[101];
+        for (int i = 0; i < nums1.length; i++) {
+            frequencyOne[nums1[i]]++;
+            frequencyTwo[nums2[i]]++;
+        }
+        int productSum = 0;
+        int idxOne = 1;
+        int idxTwo = 100;
+        while (idxOne < 101 && idxTwo > 0) {
+            if (frequencyOne[idxOne] == 0) {
+                idxOne++;
+            } else if (frequencyTwo[idxTwo] == 0) {
+                idxTwo--;
+            } else {
+                productSum += idxOne * idxTwo;
+                frequencyOne[idxOne]--;
+                frequencyTwo[idxTwo]--;
+            }
+        }
+        return productSum;
     }
-    int idxOne = 0;
-    int idxTwo = 100;
-    int sum = 0;
-    while (idxOne < 101 && idxTwo >= 0) {
-      while (idxOne < 101 && frequencyOne[idxOne] == 0) {
-        idxOne++;
-      }
-      while (idxTwo >= 0 && frequencyTwo[idxTwo] == 0) {
-        idxTwo--;
-      }
-      if (idxOne == 101 || idxTwo == -1) {
-        break;
-      }
-      int counter = Math.min(frequencyOne[idxOne], frequencyTwo[idxTwo]);
-      sum += counter * idxOne * idxTwo;
-      frequencyOne[idxOne] -= counter;
-      frequencyTwo[idxTwo] -= counter;
-    }
-    return sum;
-  }   
 }

From 113c6829c318263f68ae8f415c0f93c2bbd74ecb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 2 Dec 2022 17:58:28 -0800
Subject: [PATCH 1471/2175] Update Sort Characters By Frequency.java

---
 Medium/Sort Characters By Frequency.java | 63 ++++++++++--------------
 1 file changed, 27 insertions(+), 36 deletions(-)

diff --git a/Medium/Sort Characters By Frequency.java b/Medium/Sort Characters By Frequency.java
index d85dc32a..7c0978bc 100644
--- a/Medium/Sort Characters By Frequency.java	
+++ b/Medium/Sort Characters By Frequency.java	
@@ -1,41 +1,32 @@
 class Solution {
-  public String frequencySort(String s) {
-    int[] freqMap = new int[62];
-    int maxFrequency = 0;
-    for (char c : s.toCharArray()) {
-      int charIdx = getCharIndex(c);
-      freqMap[charIdx]++;
-      maxFrequency = Math.max(maxFrequency, freqMap[charIdx]);
-    }
-    List<Character>[] revMap = new List[maxFrequency + 1];
-    for (int i = 0; i < 62; i++) {
-      char c = getDecodedChar(i);
-      int currFreq = freqMap[i];
-      if (currFreq != 0) {
-        if (revMap[currFreq] == null) {
-          revMap[currFreq] = new ArrayList<>();
+    
+    private static final String ALL_LETTERS = 
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    
+    public String frequencySort(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int maxFrequency = 0;
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+            maxFrequency = Math.max(maxFrequency, map.get(c));
         }
-        revMap[currFreq].add(c);
-      }
-    }
-    StringBuilder sb = new StringBuilder();
-    for (int i = maxFrequency; i > 0; i--) {
-      if (revMap[i] != null) {
-        List<Character> characterList = revMap[i];
-        for (char c : characterList) {
-          sb.append(String.valueOf(c).repeat(i));
+        List<Character>[] frequencyToChar = new List[maxFrequency + 1];
+        for (char c : map.keySet()) {
+            if (frequencyToChar[map.get(c)] == null) {
+                frequencyToChar[map.get(c)] = new ArrayList<>();
+            }
+            frequencyToChar[map.get(c)].add(c);
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = maxFrequency; i > 0; i--) {
+            List<Character> characters = frequencyToChar[i] == null ? 
+                new ArrayList<>() : frequencyToChar[i];
+            for (char c : characters) {
+                for (int j = 0; j < i; j++) {
+                    sb.append(c);
+                }
+            }
         }
-      }
+        return sb.toString();
     }
-    return sb.toString();
-  }
-
-  private char getDecodedChar(int idx) {
-    return (char) (idx < 26 ? 97 + idx : (idx >= 52 ? 48 + idx - 52 : 65 + idx - 26));
-  }
-
-  private int getCharIndex(char c) {
-    return Character.isDigit(c) ? 52 + c - '0'
-        : (Character.isUpperCase(c) ? c - 'A' + 26 : c - 'a');
-  }
 }

From 115f63273228150273361f99273264895fcb3dc1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 4 Dec 2022 16:23:16 -0800
Subject: [PATCH 1472/2175] Create Circular Sentence.java

---
 Easy/Circular Sentence.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Circular Sentence.java

diff --git a/Easy/Circular Sentence.java b/Easy/Circular Sentence.java
new file mode 100644
index 00000000..51b21134
--- /dev/null
+++ b/Easy/Circular Sentence.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public boolean isCircularSentence(String sentence) {
+        String[] words = sentence.split("\\s+");
+        int n = words.length;
+        for (int i = 0; i < n - 1; i++) {
+            char lastCharOfCurrentWord = words[i].charAt(words[i].length() - 1);
+            char firstCharOfNextWord = words[i + 1].charAt(0);
+            if (lastCharOfCurrentWord != firstCharOfNextWord) {
+                return false;
+            }
+        }
+        char lastCharOfLastWord = words[n - 1].charAt(words[n - 1].length() - 1);
+        char firstCharOfFirstWord = words[0].charAt(0);
+        return lastCharOfLastWord == firstCharOfFirstWord;
+    }
+}

From e41fdb30da2687e6b40d00db24ef7d2f706c776e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 5 Dec 2022 07:05:17 -0800
Subject: [PATCH 1473/2175] Create Divide Players Into Teams of Equal
 Skill.java

---
 ...ide Players Into Teams of Equal Skill.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Divide Players Into Teams of Equal Skill.java

diff --git a/Medium/Divide Players Into Teams of Equal Skill.java b/Medium/Divide Players Into Teams of Equal Skill.java
new file mode 100644
index 00000000..bebcec21
--- /dev/null
+++ b/Medium/Divide Players Into Teams of Equal Skill.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public long dividePlayers(int[] skill) {
+        Arrays.sort(skill);
+        long totalChemistry = 0;
+        int start = 0;
+        int end = skill.length - 1;
+        int totalSkill = skill[start] + skill[end];
+        while (start < end) {
+            int currTotal = skill[start] + skill[end];
+            if (currTotal != totalSkill) {
+                return -1;
+            }
+            totalChemistry += skill[start] * skill[end];
+            start++;
+            end--;
+        }
+        return totalChemistry;
+    }
+}

From 31e3692033b5707773e492a822e1ce895b55474a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 6 Dec 2022 17:25:20 -0800
Subject: [PATCH 1474/2175] Update Range Sum of BST.java

---
 Easy/Range Sum of BST.java | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/Easy/Range Sum of BST.java b/Easy/Range Sum of BST.java
index b3d21555..3ed8dfdd 100644
--- a/Easy/Range Sum of BST.java	
+++ b/Easy/Range Sum of BST.java	
@@ -14,22 +14,22 @@
  * }
  */
 class Solution {
-  public int rangeSumBST(TreeNode root, int low, int high) {
-    Stack<TreeNode> stack = new Stack<>();
-    stack.push(root);
-    int sum = 0;
-    while (!stack.isEmpty()) {
-        TreeNode removed = stack.pop();
-        if (removed.val > low && removed.left != null) { 
-          stack.push(removed.left); 
-        } 
-        if (removed.val < high && removed.right != null) { 
-          stack.push(removed.right); 
-        }
-        if (low <= removed.val && removed.val <= high) {
-          sum += removed.val; 
+    public int rangeSumBST(TreeNode root, int low, int high) {
+        int sum = 0;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            TreeNode removed = queue.remove();
+            if (removed.val >= low && removed.val <= high) {
+                sum += removed.val;
+            }
+            if (removed.val >= low && removed.left != null) {
+                queue.add(removed.left);
+            }
+            if (removed.val <= high && removed.right != null) {
+                queue.add(removed.right);
+            }
         }
+        return sum;
     }
-    return sum;
-  }
 }

From 78dad25c23a39aeb7d419d3a59a394fcccd0095d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Dec 2022 07:10:09 -0800
Subject: [PATCH 1475/2175] Update Design an Expression Tree With Evaluate
 Function.java

---
 ...xpression Tree With Evaluate Function.java | 108 ++++++++++--------
 1 file changed, 61 insertions(+), 47 deletions(-)

diff --git a/Medium/Design an Expression Tree With Evaluate Function.java b/Medium/Design an Expression Tree With Evaluate Function.java
index 123e21df..e01eb49f 100644
--- a/Medium/Design an Expression Tree With Evaluate Function.java	
+++ b/Medium/Design an Expression Tree With Evaluate Function.java	
@@ -4,50 +4,56 @@
  */
 
 abstract class Node {
-  public abstract int evaluate();
-  // define your fields here
+    public abstract int evaluate();
+    // define your fields here
 };
 
+
 class NumericNode extends Node {
-  
-  private int val;
-  
-  public NumericNode(int val) {
-    this.val = val;  
-  }
-  
-  public int evaluate() {
-    return this.val;
-  }
+    private int val;
+    
+    public NumericNode(int val) {
+        this.val = val;
+    }
+    
+    @Override
+    public int evaluate() {
+        return this.val;
+    }
 }
 
+
 class OperatorNode extends Node {
-  private char operator;
-  private Node leftNode;
-  private Node rightNode;
-  
-  public OperatorNode(char operator, Node leftNode, Node rightNode) {
-    this.operator = operator;
-    this.leftNode = leftNode;
-    this.rightNode = rightNode;
-  }
-  
-  public int evaluate() {
-    int leftValue = this.leftNode == null ? 0 : this.leftNode.evaluate();
-    int rightValue = this.rightNode == null ? 0 : this.rightNode.evaluate();
-    if (this.operator == '+') {
-      return leftValue + rightValue;
-    } else if (this.operator == '-') {
-      return leftValue - rightValue;
-    } else if (this.operator == '*') {
-      return leftValue * rightValue;
-    } else {
-      return leftValue / rightValue;
+    private char operator;
+    private Node left;
+    private Node right;
+    
+    public OperatorNode(char operator) {
+        this.operator = operator;
+        this.left = null;
+        this.right = null;
+    }
+    
+    @Override
+    public int evaluate() {
+        return switch(operator) {
+            case '+' -> left.evaluate() + right.evaluate();
+            case '-' -> left.evaluate() - right.evaluate();
+            case '*' -> left.evaluate() * right.evaluate();
+            case '/' -> left.evaluate() / right.evaluate();
+            default -> 0;
+        };
+    }
+    
+    public void setRightNode(Node right) {
+        this.right = right;
+    }
+    
+    public void setLeftNode(Node left) {
+        this.left = left;
     }
-  }
 }
 
-
 /**
  * This is the TreeBuilder class.
  * You can treat it as the driver code that takes the postinfix input 
@@ -55,19 +61,27 @@ public int evaluate() {
  */
 
 class TreeBuilder {
-  Node buildTree(String[] postfix) {
-    Stack<Node> stack = new Stack<>();
-    for(String token: postfix){
-      if (token.equals("*") || token.equals("+") || token.equals("-") || token.equals("/")) {
-        Node o2 = stack.pop();
-        Node o1 = stack.pop();
-        stack.push(new OperatorNode(token.charAt(0), o1, o2));
-      } else{
-        stack.push(new NumericNode(Integer.parseInt(token)));
-      }
+    private static final Set<String> OPERATORS = Set.of("+", "-", "/", "*");
+    
+    Node buildTree(String[] postfix) {
+        int[] idx = {postfix.length - 1};
+        return buildTree(postfix, idx);
+    }
+    
+    private Node buildTree(String[] postfix, int[] idx) {
+        if (idx[0] < 0) {
+            return null;
+        }
+        String val = postfix[idx[0]--];
+        if (OPERATORS.contains(val)) {
+            OperatorNode node = new OperatorNode(val.charAt(0));
+            node.setRightNode(buildTree(postfix, idx));
+            node.setLeftNode(buildTree(postfix, idx));
+            return node;
+        }
+        NumericNode node = new NumericNode(Integer.parseInt(val));
+        return node;
     }
-    return stack.pop();
-  }
 };
 
 

From 2446f4b5c48df4479b74c241e97da53bf152c004 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Dec 2022 13:32:53 -0800
Subject: [PATCH 1476/2175] Update Valid Word Square.java

---
 Easy/Valid Word Square.java | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Easy/Valid Word Square.java b/Easy/Valid Word Square.java
index 69e1925d..392d8392 100644
--- a/Easy/Valid Word Square.java	
+++ b/Easy/Valid Word Square.java	
@@ -1,16 +1,13 @@
 class Solution {
-  public boolean validWordSquare(List<String> words) {
-    return IntStream.range(0, words.size())
-        .allMatch(i -> words.get(i).equals(verticalRepresentation(words, i)));
-  }
-
-  private String verticalRepresentation(List<String> words, int col){
-    StringBuilder sb = new StringBuilder();
-    for (String word : words) {
-      if (col < word.length()) {
-        sb.append(word.charAt(col));
-      }
+    public boolean validWordSquare(List<String> words) {
+        int n = words.size();
+        for (int i = 0; i < n; i++){
+            for (int j = 0; j < words.get(i).length(); j++){
+                if(j >= n || words.get(j).length() <= i || words.get(j).charAt(i) != words.get(i).charAt(j)) {
+                    return false;
+                }
+            }
+        }
+        return true;
     }
-    return sb.toString();
-  }
 }

From f5a0c5ccd9016a35202cf2719443bb7519c434a0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Dec 2022 18:54:48 -0800
Subject: [PATCH 1477/2175] Update Leaf-Similar Trees.java

---
 Easy/Leaf-Similar Trees.java | 38 +++++++++++++++---------------------
 1 file changed, 16 insertions(+), 22 deletions(-)

diff --git a/Easy/Leaf-Similar Trees.java b/Easy/Leaf-Similar Trees.java
index 38bb0ab9..1ac4d480 100644
--- a/Easy/Leaf-Similar Trees.java	
+++ b/Easy/Leaf-Similar Trees.java	
@@ -14,29 +14,23 @@
  * }
  */
 class Solution {
-  public boolean leafSimilar(TreeNode root1, TreeNode root2) {
-    return getLeaves(root1).equals(getLeaves(root2));
-  }   
-  
-  private List<Integer> getLeaves(TreeNode root) {
-    Stack<TreeNode> stack = new Stack<>();
-    List<Integer> leaves = new ArrayList<>();
-    while (root != null) {
-      stack.push(root);
-      root = root.left;
+    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+        StringBuilder leavesOne = new StringBuilder();
+        StringBuilder leavesTwo = new StringBuilder();
+        populateLeaves(root1, leavesOne);
+        populateLeaves(root2, leavesTwo);
+        return leavesOne.toString().equals(leavesTwo.toString());
     }
-    while (!stack.isEmpty()) {
-      TreeNode removed = stack.pop();
-      if (removed.left == null && removed.right == null) {
-        leaves.add(removed.val);
-      } else {
-        TreeNode rightNode = removed.right;
-        while (rightNode != null) {
-          stack.push(rightNode);
-          rightNode = rightNode.left;
+    
+    private void populateLeaves(TreeNode root, StringBuilder leaves) {
+        if (root == null) {
+            return;
         }
-      }
+        if (root.left == null && root.right == null) {
+            leaves.append(root.val).append(",");
+            return;
+        }
+        populateLeaves(root.left, leaves);
+        populateLeaves(root.right, leaves);
     }
-    return leaves;
-  }
 }

From 4bcd108338b86f2326ab9206633a14c39aec3650 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Dec 2022 09:06:36 -0800
Subject: [PATCH 1478/2175] Create XOR Operation in an Array.java

---
 Easy/XOR Operation in an Array.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/XOR Operation in an Array.java

diff --git a/Easy/XOR Operation in an Array.java b/Easy/XOR Operation in an Array.java
new file mode 100644
index 00000000..17908959
--- /dev/null
+++ b/Easy/XOR Operation in an Array.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public int xorOperation(int n, int start) {
+        int xor = start;
+        for (int i = 1; i < n; i++) {
+            int nextNum = start + 2 * i;
+            xor = xor ^ nextNum;
+        }
+        return xor;
+    }
+}

From 785a04d97ef2dbb81982d8da6ba9b597cfe82a77 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Dec 2022 09:21:12 -0800
Subject: [PATCH 1479/2175] Create Largest Local Values in a Matrix.java

---
 Easy/Largest Local Values in a Matrix.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Largest Local Values in a Matrix.java

diff --git a/Easy/Largest Local Values in a Matrix.java b/Easy/Largest Local Values in a Matrix.java
new file mode 100644
index 00000000..570443a9
--- /dev/null
+++ b/Easy/Largest Local Values in a Matrix.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[][] largestLocal(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int[][] result = new int[rows - 2][cols - 2];
+        for (int i = 0; i < rows - 2; i++) {
+            for (int j = 0; j < cols - 2; j++) {
+                for (int k = i; k < i + 3; k++) {
+                    for (int l = j; l < j + 3; l++) {
+                        result[i][j] = Math.max(result[i][j], grid[k][l]);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

From b265e9d12baf76f919f69b0e4d37f03b8770908e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Dec 2022 09:21:26 -0800
Subject: [PATCH 1480/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ddb9b55e..92c01bb6 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 1100+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1200+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count

From e085714d8caaca4531f99522fff03693b0f0bc15 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Dec 2022 09:32:42 -0800
Subject: [PATCH 1481/2175] Update Number of Connected Components in an
 Undirected Graph.java

---
 ...ted Components in an Undirected Graph.java | 72 +++++++------------
 1 file changed, 25 insertions(+), 47 deletions(-)

diff --git a/Medium/Number of Connected Components in an Undirected Graph.java b/Medium/Number of Connected Components in an Undirected Graph.java
index e794deea..59e0be29 100644
--- a/Medium/Number of Connected Components in an Undirected Graph.java	
+++ b/Medium/Number of Connected Components in an Undirected Graph.java	
@@ -1,51 +1,29 @@
 class Solution {
-  public int countComponents(int n, int[][] edges) {
-    DisjointSet disjointSet = new DisjointSet(n);
-    for (int[] edge : edges) {
-      disjointSet.union(edge[0], edge[1]);
-    }
-    Set<Integer> rootSet = new HashSet<>();
-    for (int i = 0; i < n; i++) {
-      rootSet.add(disjointSet.find(i));
-    }
-    return rootSet.size();
-  }
-
-  private static class DisjointSet {
-
-    private final int[] root;
-    private final int[] rank;
-
-    public DisjointSet(int size) {
-      this.root = new int[size];
-      this.rank = new int[size];
-      for (int i = 0; i < size; i++) {
-        this.root[i] = i;
-        this.rank[i] = 1;
-      }
-    }
-
-    public void union(int nodeOne, int nodeTwo) {
-      int rootOne = find(nodeOne);
-      int rootTwo = find(nodeTwo);
-      if (rootOne != rootTwo) {
-        if (this.rank[rootOne] > this.rank[rootTwo]) {
-          this.root[rootTwo] = rootOne;
-        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
-          this.root[rootOne] = rootTwo;
-        } else {
-          this.root[rootTwo] = rootOne;
-          this.rank[rootOne]++;
+    public int countComponents(int n, int[][] edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+            graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
         }
-      }
-    }
-
-
-    public int find(int node) {
-      if (node == root[node]) {
-        return node;
-      }
-      return root[node] = find(root[node]);
+        int connectedComponentCount = 0;
+        Set<Integer> visited = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            if (!visited.contains(i)) {
+                Queue<Integer> queue = new LinkedList<>();
+                visited.add(i);
+                queue.add(i);
+                while (!queue.isEmpty()) {
+                    int removed = queue.remove();
+                    for (Integer neighbor : graph.getOrDefault(removed, new HashSet<>())) {
+                        if (!visited.contains(neighbor)) {
+                            queue.add(neighbor);
+                            visited.add(neighbor);
+                        }
+                    }
+                }
+                connectedComponentCount++;
+            }
+        }
+        return connectedComponentCount;
     }
-  }
 }

From c8738e752f5ac6c600a310b58337240ed342df7d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Dec 2022 17:18:06 -0800
Subject: [PATCH 1482/2175] Update Maximum Difference Between Node and
 Ancestor.java

---
 ... Difference Between Node and Ancestor.java | 44 ++++++++++++++-----
 1 file changed, 33 insertions(+), 11 deletions(-)

diff --git a/Medium/Maximum Difference Between Node and Ancestor.java b/Medium/Maximum Difference Between Node and Ancestor.java
index 75d54cfa..b623f146 100644
--- a/Medium/Maximum Difference Between Node and Ancestor.java	
+++ b/Medium/Maximum Difference Between Node and Ancestor.java	
@@ -14,16 +14,38 @@
  * }
  */
 class Solution {
-  public int maxAncestorDiff(TreeNode root) {
-    return dfs(root, root.val, root.val);
-  }
-  
-  private int dfs(TreeNode root, int min, int max) {
-    if (root == null) {
-      return max - min;
+    public int maxAncestorDiff(TreeNode root) {
+        int maxDiff = 0;
+        Queue<NodeValuePair> queue = new LinkedList<>();
+        queue.add(new NodeValuePair(root, root.val, root.val));
+        while (!queue.isEmpty()) {
+            NodeValuePair removed = queue.remove();
+            TreeNode node = removed.node;
+            Integer minNodeValue = removed.minNodeValue;
+            Integer maxNodeValue = removed.maxNodeValue;
+            maxDiff = Math.max(maxDiff, Math.max(Math.abs(node.val - minNodeValue), Math.abs(node.val - maxNodeValue)));
+            Integer updatedMinNodeValue = Math.min(node.val, minNodeValue);
+            Integer updatedMaxNodeValue = Math.max(node.val, maxNodeValue);
+            if (node.left != null) {
+                queue.add(new NodeValuePair(node.left, updatedMinNodeValue, updatedMaxNodeValue));
+            }
+            if (node.right != null) {
+                queue.add(new NodeValuePair(node.right, updatedMinNodeValue, updatedMaxNodeValue));
+            }
+        }
+        return maxDiff;
+    }
+    
+    
+    private static class NodeValuePair {
+        private TreeNode node;
+        private Integer minNodeValue;
+        private Integer maxNodeValue;
+        
+        public NodeValuePair(TreeNode node, Integer minNodeValue, Integer maxNodeValue) {
+            this.node = node;
+            this.minNodeValue = minNodeValue;
+            this.maxNodeValue = maxNodeValue;
+        }
     }
-    max = Math.max(root.val, max);
-    min = Math.min(root.val, min);
-    return Math.max(dfs(root.left, min, max), dfs(root.right, min, max));
-  }
 }

From 6b413315ca240c5ca220caa614a4fda11cb8d483 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 10 Dec 2022 15:27:20 -0800
Subject: [PATCH 1483/2175] Create Maximum Product of Splitted Binary Tree.java

---
 ...ximum Product of Splitted Binary Tree.java | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/Maximum Product of Splitted Binary Tree.java

diff --git a/Medium/Maximum Product of Splitted Binary Tree.java b/Medium/Maximum Product of Splitted Binary Tree.java
new file mode 100644
index 00000000..72a36750
--- /dev/null
+++ b/Medium/Maximum Product of Splitted Binary Tree.java	
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int maxProduct(TreeNode root) {
+        List<Integer> allNodeSums = new ArrayList<>();
+        long totalSum = treeSum(root, allNodeSums);
+        long best = 0;
+        for (long sum : allNodeSums) {
+            best = Math.max(best, sum * (totalSum - sum));
+        }
+        return (int) (best % 1000_000_007);
+    }
+    
+    private int treeSum(TreeNode root, List<Integer> allNodeSums) {
+        if (root == null) {
+            return 0;
+        }
+        int leftSum = treeSum(root.left, allNodeSums);
+        int rightSum = treeSum(root.right, allNodeSums);
+        int totalSum = leftSum + rightSum + root.val;
+        allNodeSums.add(totalSum);
+        return totalSum;
+    }
+}

From e274ecf892388dfae8e765220fc608d5a7607366 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 10 Dec 2022 15:33:59 -0800
Subject: [PATCH 1484/2175] Create Maximum Value of a String in an Array.java

---
 Easy/Maximum Value of a String in an Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Maximum Value of a String in an Array.java

diff --git a/Easy/Maximum Value of a String in an Array.java b/Easy/Maximum Value of a String in an Array.java
new file mode 100644
index 00000000..29b0ec25
--- /dev/null
+++ b/Easy/Maximum Value of a String in an Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maximumValue(String[] strs) {
+        return Arrays.stream(strs)
+                .mapToInt(Solution::getStringValue)
+                .max()
+                .orElse(0);
+    }
+
+    private static int getStringValue(String s) {
+        for (char c : s.toCharArray()) {
+            if (!Character.isDigit(c)) {
+                return s.length();
+            }
+        }
+        return Integer.parseInt(s);
+    }
+}

From 087654b6cd0a153c8e1dac0d4cda069225e578e9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 10 Dec 2022 15:48:47 -0800
Subject: [PATCH 1485/2175] Create Maximum Star Sum of a Graph.java

---
 Medium/Maximum Star Sum of a Graph.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Maximum Star Sum of a Graph.java

diff --git a/Medium/Maximum Star Sum of a Graph.java b/Medium/Maximum Star Sum of a Graph.java
new file mode 100644
index 00000000..f54f2f83
--- /dev/null
+++ b/Medium/Maximum Star Sum of a Graph.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxStarSum(int[] vals, int[][] edges, int k) {
+        Map<Integer, PriorityQueue<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], node -> new PriorityQueue<>(Comparator.reverseOrder())).add(vals[edge[1]]);
+            graph.computeIfAbsent(edge[1], node -> new PriorityQueue<>(Comparator.reverseOrder())).add(vals[edge[0]]);
+        }
+        int maxSum = Integer.MIN_VALUE;
+        for (int i = 0; i < vals.length; i++) {
+            int currSum = vals[i];
+            PriorityQueue<Integer> pq = graph.getOrDefault(i, new PriorityQueue<>());
+            for (int j = 0; j < k && !pq.isEmpty(); j++){
+                currSum += Math.max(pq.poll(), 0);
+            }
+            maxSum = Math.max(maxSum, currSum);
+        }
+        return maxSum;
+    }
+}

From fbdfc0054f2ce1852d8a5c959029dc3593af9745 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 15 Dec 2022 19:49:00 -0800
Subject: [PATCH 1486/2175] Update Implement Queue using Stacks.java

---
 Easy/Implement Queue using Stacks.java | 68 ++++++++++++--------------
 1 file changed, 31 insertions(+), 37 deletions(-)

diff --git a/Easy/Implement Queue using Stacks.java b/Easy/Implement Queue using Stacks.java
index c2a5254d..fd2b165e 100644
--- a/Easy/Implement Queue using Stacks.java	
+++ b/Easy/Implement Queue using Stacks.java	
@@ -1,46 +1,40 @@
 class MyQueue {
+    
+    private final Stack<Integer> stackOne;
+    private final Stack<Integer> stackTwo;
 
-  /** Initialize your data structure here. */
-  Stack<Integer> stack;
-  Stack<Integer> revStack;
-  public MyQueue() {
-    stack = new Stack<>();
-    revStack = new Stack<>();
-  }
-
-  /** Push element x to the back of queue. */
-  public void push(int x) {
-    stack.push(x);
-  }
-
-  /** Removes the element from in front of queue and returns that element. */
-  public int pop() {
-    while (!stack.isEmpty()) {
-      revStack.push(stack.pop());
+    public MyQueue() {
+        this.stackOne = new Stack<>();
+        this.stackTwo = new Stack<>();
     }
-    int num = revStack.pop();
-    while (!revStack.isEmpty()) {
-      stack.push(revStack.pop());
+    
+    public void push(int x) {
+        this.stackOne.push(x);
     }
-    return num;
-  }
-
-  /** Get the front element. */
-  public int peek() {
-    while (!stack.isEmpty()) {
-      revStack.push(stack.pop());
+    
+    public int pop() {
+        exchangeElements(stackOne, stackTwo);
+        int popped = stackTwo.pop();
+        exchangeElements(stackTwo, stackOne);
+        return popped;
     }
-    int num = revStack.peek();
-    while (!revStack.isEmpty()) {
-      stack.push(revStack.pop());
+    
+    public int peek() {
+        exchangeElements(stackOne, stackTwo);
+        int peeked = stackTwo.peek();
+        exchangeElements(stackTwo, stackOne);
+        return peeked;
+    }
+    
+    public boolean empty() {
+        return stackOne.isEmpty();
+    }
+    
+    private void exchangeElements(Stack<Integer> stack1, Stack<Integer> stack2) {
+        while (!stack1.isEmpty()) {
+            stack2.push(stack1.pop());
+        }
     }
-    return num;
-  }
-
-  /** Returns whether the queue is empty. */
-  public boolean empty() {
-    return stack.isEmpty();
-  }
 }
 
 /**

From 9c5f812efa54980ba27f7c1bb0929a6b765a1a19 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 17 Dec 2022 08:15:32 -0800
Subject: [PATCH 1487/2175] Update Evaluate Reverse Polish Notation.java

---
 Medium/Evaluate Reverse Polish Notation.java | 45 ++++++++++----------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/Medium/Evaluate Reverse Polish Notation.java b/Medium/Evaluate Reverse Polish Notation.java
index 483049db..17b3a709 100644
--- a/Medium/Evaluate Reverse Polish Notation.java	
+++ b/Medium/Evaluate Reverse Polish Notation.java	
@@ -1,27 +1,26 @@
 class Solution {
-  public int evalRPN(String[] tokens) {
-    Stack<Integer> stack = new Stack<>();
-    String operations = "+-/*";
-    for (String token : tokens) {
-      stack.push(operations.contains(token) ? Objects
-          .requireNonNull(performOperation(stack.pop(), stack.pop(), token))
-          : Integer.parseInt(token));
+    
+    private static final Set<String> OPERATIONS = Set.of("*", "+", "/", "-");
+    
+    public int evalRPN(String[] tokens) {
+        Stack<Integer> stack = new Stack<>();
+        for (String token : tokens) {
+            if (OPERATIONS.contains(token)) {
+                stack.push(performOperation(stack.pop(), stack.pop(), token));
+            } else {
+                stack.push(Integer.parseInt(token));
+            }
+        }
+        return stack.pop();
     }
-    return stack.pop();
-  }
-
-  private Integer performOperation(Integer secondOperand, Integer firstOperand, String operation) {
-    switch (operation) {
-      case "+":
-        return firstOperand + secondOperand;
-      case "-":
-        return firstOperand - secondOperand;
-      case "*":
-        return firstOperand * secondOperand;
-      case "/":
-        return firstOperand / secondOperand;
-      default:
-        return null;
+    
+    private static int performOperation(int num2, int num1, String operation) throws UnsupportedOperationException {
+        return switch(operation) {
+            case "+" -> num1 + num2;
+            case "-" -> num1 - num2;
+            case "*" -> num1 * num2;
+            case "/" -> num1 / num2;
+            default -> throw new UnsupportedOperationException("Operation not supported");
+        };
     }
-  }
 }

From d36cc6fa3adebcf5efd85afa882b87df8a322f46 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Dec 2022 06:40:30 -0800
Subject: [PATCH 1488/2175] Create Count Pairs Of Similar Strings.java

---
 Easy/Count Pairs Of Similar Strings.java | 26 ++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Easy/Count Pairs Of Similar Strings.java

diff --git a/Easy/Count Pairs Of Similar Strings.java b/Easy/Count Pairs Of Similar Strings.java
new file mode 100644
index 00000000..d9b1f7f9
--- /dev/null
+++ b/Easy/Count Pairs Of Similar Strings.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int similarPairs(String[] words) {
+        Map<String, Integer> map = new HashMap<>();
+        int pairCount = 0;
+        for (String word : words) {
+            String key = buildSortedCharString(word);
+            pairCount += map.getOrDefault(key, 0);
+            map.put(key, map.getOrDefault(key, 0) + 1);
+        }
+        return pairCount;
+    }
+    
+    private static String buildSortedCharString(String s) {
+        boolean[] exists = new boolean[26];
+        for (char c : s.toCharArray()) {
+            exists[c - 'a'] = true;
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 26; i++) {
+            if (exists[i]) {
+                sb.append((char) (97 + i));
+            }
+        }
+        return sb.toString();
+    }
+}

From d07aabcad7e83b10d73795d0d926a99803b91081 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Dec 2022 16:50:46 -0800
Subject: [PATCH 1489/2175] Update Find if Path Exists in Graph.java

---
 Easy/Find if Path Exists in Graph.java | 44 ++++++++++++--------------
 1 file changed, 21 insertions(+), 23 deletions(-)

diff --git a/Easy/Find if Path Exists in Graph.java b/Easy/Find if Path Exists in Graph.java
index cfa38aaa..7a0c6a47 100644
--- a/Easy/Find if Path Exists in Graph.java	
+++ b/Easy/Find if Path Exists in Graph.java	
@@ -1,28 +1,26 @@
 class Solution {
-  public boolean validPath(int n, int[][] edges, int start, int end) {
-    Map<Integer, Set<Integer>> graph = new HashMap<>();
-    for (int[] edge : edges) {
-      graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
-      graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(start);
-    Set<Integer> visited = new HashSet<>();
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int removed = queue.remove();
-        if (removed == end) {
-          return true;
+    public boolean validPath(int n, int[][] edges, int source, int destination) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
         }
-        visited.add(removed);
-        for (Integer connection : graph.getOrDefault(removed, new HashSet<>())) {
-          if (!visited.contains(connection)) {
-            queue.add(connection);
-          }
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(source);
+        Set<Integer> visited = new HashSet<>();
+        visited.add(source);
+        while (!queue.isEmpty()) {
+            Integer removed = queue.remove();
+            if (removed == destination) {
+                return true;
+            }
+            for (Integer connection : graph.getOrDefault(removed, new ArrayList<>())) {
+                if (!visited.contains(connection)) {
+                    queue.add(connection);
+                    visited.add(connection);
+                }
+            }
         }
-      }
+        return false;
     }
-    return false;
-  }
 }

From e5b615220164071dfed7f08df0512d06af5877bd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 19 Dec 2022 13:18:29 -0800
Subject: [PATCH 1490/2175] Create Add Edges to Make Degrees of All Nodes
 Even.java

---
 ...ges to Make Degrees of All Nodes Even.java | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 Hard/Add Edges to Make Degrees of All Nodes Even.java

diff --git a/Hard/Add Edges to Make Degrees of All Nodes Even.java b/Hard/Add Edges to Make Degrees of All Nodes Even.java
new file mode 100644
index 00000000..2258af63
--- /dev/null
+++ b/Hard/Add Edges to Make Degrees of All Nodes Even.java	
@@ -0,0 +1,48 @@
+class Solution {
+    public boolean isPossible(int n, List<List<Integer>> edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (List<Integer> edge : edges) {
+            graph.computeIfAbsent(edge.get(0), k -> new HashSet<>()).add(edge.get(1));
+            graph.computeIfAbsent(edge.get(1), k -> new HashSet<>()).add(edge.get(0));
+        }
+        List<Integer> nodeWithOddEdges = graph.entrySet()
+            .stream()
+            .filter(e -> e.getValue().size() % 2 != 0)
+            .map(Map.Entry::getKey)
+            .collect(Collectors.toList());
+        if (nodeWithOddEdges.size() == 0) {
+            return true;
+        }
+        if (nodeWithOddEdges.size() == 2) {
+            Integer nodeOne = nodeWithOddEdges.get(0);
+            Integer nodeTwo = nodeWithOddEdges.get(1);
+            if (!hasEdge(graph, nodeOne, nodeTwo)) {
+                return true;
+            }
+            for (int i = 1; i <= n; i++) {
+                if (i == nodeOne || i == nodeTwo) {
+                    continue;
+                }
+                if (!hasEdge(graph, i, nodeOne) && !hasEdge(graph, i, nodeTwo)) {
+                    return true;
+                }
+            }
+        }
+        if (nodeWithOddEdges.size() == 4) {
+            Integer nodeOne = nodeWithOddEdges.get(0);
+            Integer nodeTwo = nodeWithOddEdges.get(1);
+            Integer nodeThree = nodeWithOddEdges.get(2);
+            Integer nodeFour = nodeWithOddEdges.get(3);
+            if ((!hasEdge(graph, nodeOne, nodeTwo) && !hasEdge(graph, nodeThree, nodeFour)) || 
+                (!hasEdge(graph, nodeOne, nodeThree) && !hasEdge(graph, nodeTwo, nodeFour)) || 
+                (!hasEdge(graph, nodeOne, nodeFour) && !hasEdge(graph, nodeTwo, nodeThree))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    private static boolean hasEdge(Map<Integer, Set<Integer>> graph, int nodeOne, int nodeTwo) {
+        return graph.getOrDefault(nodeOne, new HashSet<>()).contains(nodeTwo);
+    }
+}

From a854e63dfc56e32291cd1647c431e08cb4c6dcf8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 19 Dec 2022 18:41:16 -0800
Subject: [PATCH 1491/2175] Update Keys and Rooms.java

---
 Medium/Keys and Rooms.java | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/Medium/Keys and Rooms.java b/Medium/Keys and Rooms.java
index 6a2f8c3f..a4fd783a 100644
--- a/Medium/Keys and Rooms.java	
+++ b/Medium/Keys and Rooms.java	
@@ -1,19 +1,18 @@
 class Solution {
     public boolean canVisitAllRooms(List<List<Integer>> rooms) {
-        Stack<Integer> stack = new Stack<>();
-        Set<Integer> set = new HashSet<>();
-        set.add(0);
-        stack.add(0);
-        while (!stack.isEmpty()) {
-            int keyPopped = stack.pop();
-            List<Integer> keys = rooms.get(keyPopped);
-            for (Integer key : keys) {
-                if (!set.contains(key)) {
-                    stack.push(key);
-                    set.add(key);
+        Set<Integer> visited = new HashSet<>();
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(0);
+        visited.add(0);
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer nextRoom : rooms.get(removed)) {
+                if (!visited.contains(nextRoom)) {
+                    queue.add(nextRoom);
+                    visited.add(nextRoom);
                 }
             }
         }
-        return set.size() == rooms.size();
+        return visited.size() == rooms.size();
     }
 }

From 27b93972f221d1e43babb8cb12d7b81da50ab9d4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 21 Dec 2022 11:29:49 -0800
Subject: [PATCH 1492/2175] Create Possible Bipartition.java

---
 Medium/Possible Bipartition.java | 38 ++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Medium/Possible Bipartition.java

diff --git a/Medium/Possible Bipartition.java b/Medium/Possible Bipartition.java
new file mode 100644
index 00000000..4d2a0500
--- /dev/null
+++ b/Medium/Possible Bipartition.java	
@@ -0,0 +1,38 @@
+class Solution {
+    public boolean possibleBipartition(int n, int[][] dislikes) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int[] dislike : dislikes) {
+            map.computeIfAbsent(dislike[0], k -> new ArrayList<>()).add(dislike[1]);
+            map.computeIfAbsent(dislike[1], k -> new ArrayList<>()).add(dislike[0]);
+        }
+        int[] color = new int[n + 1];
+        Arrays.fill(color, -1);
+        for (int i = 1; i <= n; i++) {
+            if (color[i] == -1) {
+                if (!bfs(i, map, color)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    
+    private boolean bfs(int node, Map<Integer, List<Integer>> map, int[] color) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(node);
+        color[node] = 0;
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer neighbor : map.getOrDefault(removed, new ArrayList<>())) {
+                if (color[neighbor] == color[removed]) {
+                    return false;
+                }
+                if (color[neighbor] == -1) {
+                    color[neighbor] = 1 - color[removed];
+                    queue.add(neighbor);
+                }
+            }
+        }
+        return true;
+    }
+}

From 2bf7a2c4394fa169963d600ae9b150da3e23cb58 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 Jan 2023 14:56:14 -0800
Subject: [PATCH 1493/2175] Create Count the Digits That Divide a Number.java

---
 Easy/Count the Digits That Divide a Number.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Count the Digits That Divide a Number.java

diff --git a/Easy/Count the Digits That Divide a Number.java b/Easy/Count the Digits That Divide a Number.java
new file mode 100644
index 00000000..085c312b
--- /dev/null
+++ b/Easy/Count the Digits That Divide a Number.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int countDigits(int num) {
+        int count = 0;
+        int copy = num;
+        while (num > 0) {
+            int digit = num % 10;
+            num /= 10;
+            if (digit != 0 && copy % digit == 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

From 9c40397d9529c19fb89e58a0da425e1cbf381180 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Jan 2023 07:56:02 -0800
Subject: [PATCH 1494/2175] Create Minimum Rounds to Complete All Tasks.java

---
 .../Minimum Rounds to Complete All Tasks.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Minimum Rounds to Complete All Tasks.java

diff --git a/Medium/Minimum Rounds to Complete All Tasks.java b/Medium/Minimum Rounds to Complete All Tasks.java
new file mode 100644
index 00000000..309810a0
--- /dev/null
+++ b/Medium/Minimum Rounds to Complete All Tasks.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int minimumRounds(int[] tasks) {
+        Map<Integer, Long> frequencyMap = Arrays.stream(tasks)
+            .boxed()
+            .collect(Collectors.groupingBy(
+                Function.identity(), 
+                HashMap::new, 
+                Collectors.counting()));
+        int rounds = 0;
+        for (Long occurrences : frequencyMap.values()) {
+            if (occurrences == 1) {
+                return -1;
+            }
+            if (occurrences % 3 == 0) {
+                rounds += (int) (occurrences / 3);
+            } else {
+                rounds += (int) (occurrences / 3 + 1);
+            }
+        }
+        return rounds;
+    }
+}

From 719bf44f00dd6998ba07eb1b59eeb85d013b90ad Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Jan 2023 16:09:13 -0800
Subject: [PATCH 1495/2175] Create Maximum Enemy Forts That Can Be
 Captured.java

---
 Easy/Maximum Enemy Forts That Can Be Captured.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Maximum Enemy Forts That Can Be Captured.java

diff --git a/Easy/Maximum Enemy Forts That Can Be Captured.java b/Easy/Maximum Enemy Forts That Can Be Captured.java
new file mode 100644
index 00000000..207f220c
--- /dev/null
+++ b/Easy/Maximum Enemy Forts That Can Be Captured.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int captureForts(int[] forts) {
+        int maximumCapture = 0;
+        for (int i = 0, j = 0; i < forts.length; i++) {
+            if (forts[i] != 0) {
+                if (forts[i] == -1 * forts[j]) {
+                    maximumCapture = Math.max(maximumCapture, i - j - 1);
+                }
+                j = i;
+            }
+        }
+        return maximumCapture;
+    }
+}

From bc70c5ce3de3cc4d2c6eb127df4fc1ca9a0aa778 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 5 Jan 2023 17:01:13 -0800
Subject: [PATCH 1496/2175] Update Maximum Ice Cream Bars.java

---
 Medium/Maximum Ice Cream Bars.java | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/Medium/Maximum Ice Cream Bars.java b/Medium/Maximum Ice Cream Bars.java
index 75d34abf..d8faca38 100644
--- a/Medium/Maximum Ice Cream Bars.java	
+++ b/Medium/Maximum Ice Cream Bars.java	
@@ -1,12 +1,18 @@
 class Solution {
-  public int maxIceCream(int[] costs, int coins) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>();
-    pq.addAll(Arrays.stream(costs).boxed().collect(Collectors.toList()));
-    int icecreamCount = 0;
-    while (!pq.isEmpty() && (coins - pq.peek()) >= 0) {
-      coins -= pq.poll();
-      icecreamCount++;
+    public int maxIceCream(int[] costs, int coins) {
+        int[] costFrequency = new int[1000_01];
+        for (int cost : costs) {
+            costFrequency[cost]++;
+        }
+        int numberOfIcecreams = 0;
+        for (int i = 1; i <= 1000_00 && coins >= i; i++) {
+            if (costFrequency[i] > 0) {
+                while (coins >= i && costFrequency[i]-- > 0) {
+                    numberOfIcecreams++;
+                    coins -= i;
+                }
+            }
+        }
+        return numberOfIcecreams;
     }
-    return icecreamCount;
-  }
 }

From e61e21200c8f2fcff2b34695094afe06832bff5b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 6 Jan 2023 13:16:55 -0800
Subject: [PATCH 1497/2175] Create Shortest Distance to Target String in a
 Circular Array.java

---
 ... to Target String in a Circular Array.java | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Easy/Shortest Distance to Target String in a Circular Array.java

diff --git a/Easy/Shortest Distance to Target String in a Circular Array.java b/Easy/Shortest Distance to Target String in a Circular Array.java
new file mode 100644
index 00000000..9280c7b9
--- /dev/null
+++ b/Easy/Shortest Distance to Target String in a Circular Array.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int closetTarget(String[] words, String target, int startIndex) {
+        int firstIdx = -1;
+        int lastIdx = -1;
+        int n = words.length;
+        int minDistance = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (words[i].equals(target)) {
+                if (firstIdx == -1) {
+                    firstIdx = i;
+                }
+                lastIdx = i;
+                minDistance = Math.min(minDistance, Math.abs(i - startIndex));
+            }
+        }
+        if (minDistance == Integer.MAX_VALUE) {
+            return -1;
+        }
+        return Math.min(minDistance, Math.min(
+            n - startIndex + firstIdx, // Reach first instance by circulating from end of array 
+            startIndex + n - lastIdx // Reach last instance by circulating from start of array
+        ));
+    }
+}

From 189cdff25edfd0ef53dbfa628a4641c268b7abfb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 7 Jan 2023 17:33:45 -0800
Subject: [PATCH 1498/2175] Create Categorize Box According to Criteria.java

---
 .../Categorize Box According to Criteria.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Categorize Box According to Criteria.java

diff --git a/Easy/Categorize Box According to Criteria.java b/Easy/Categorize Box According to Criteria.java
new file mode 100644
index 00000000..0c817a0a
--- /dev/null
+++ b/Easy/Categorize Box According to Criteria.java	
@@ -0,0 +1,23 @@
+class Solution {
+    
+    private static final int BULKY_DIMENSION_THRESHOLD = 1000_0;
+    private static final int BULKY_VOLUME_THRESHOLD = 1000_000_000;
+    private static final int HEAVY_MASS_THRESHOLD = 100;
+    
+    public String categorizeBox(int length, int width, int height, int mass) {
+        long volume = ((long) length) * width * height;
+        boolean isBulky = length >= BULKY_DIMENSION_THRESHOLD || 
+            width >= BULKY_DIMENSION_THRESHOLD || 
+            height >= BULKY_DIMENSION_THRESHOLD || 
+            mass >= BULKY_DIMENSION_THRESHOLD ||
+            volume >= BULKY_VOLUME_THRESHOLD;
+        boolean isHeavy = mass >= HEAVY_MASS_THRESHOLD;
+        if (isBulky && isHeavy) {
+            return "Both";
+        }
+        if (!(isBulky || isHeavy)) {
+            return "Neither";
+        }
+        return isBulky ? "Bulky" : "Heavy";
+    }
+}

From f06c8e3273d72e11060a0be394e204a591bc435f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Jan 2023 07:52:27 -0800
Subject: [PATCH 1499/2175] Create Maximum Count of Positive Integer and
 Negative Integer.java

---
 ...ount of Positive Integer and Negative Integer.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Maximum Count of Positive Integer and Negative Integer.java

diff --git a/Easy/Maximum Count of Positive Integer and Negative Integer.java b/Easy/Maximum Count of Positive Integer and Negative Integer.java
new file mode 100644
index 00000000..73e0dba8
--- /dev/null
+++ b/Easy/Maximum Count of Positive Integer and Negative Integer.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int maximumCount(int[] nums) {
+        int positiveCount = 0;
+        int negativeCount = 0;
+        for (int num : nums) {
+            positiveCount += num > 0 ? 1 : 0;
+            negativeCount += num < 0 ? 1 : 0;
+        }
+        return Math.max(positiveCount, negativeCount);
+    }
+}

From 18e448cd295f317da27099cbcf970eb572bf14a5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Jan 2023 18:43:32 -0800
Subject: [PATCH 1500/2175] Update Binary Tree Preorder Traversal.java

---
 Medium/Binary Tree Preorder Traversal.java | 36 ++++++++++++----------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/Medium/Binary Tree Preorder Traversal.java b/Medium/Binary Tree Preorder Traversal.java
index e2f64ac4..61765340 100644
--- a/Medium/Binary Tree Preorder Traversal.java	
+++ b/Medium/Binary Tree Preorder Traversal.java	
@@ -4,31 +4,33 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
     public List<Integer> preorderTraversal(TreeNode root) {
-        ArrayList<Integer> ans = new ArrayList<>();
         if (root == null) {
-            return ans;
+            return List.of();
         }
-        Stack<TreeNode> s = new Stack<>();
-        
-        s.push(root);
-        
-        while(s.size() > 0) {
-            TreeNode curr = s.pop();
-            ans.add(curr.val);
-            if(curr.right != null) {
-                s.push(curr.right);
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        List<Integer> result = new ArrayList<>();
+        while (!stack.isEmpty()) {
+            TreeNode removed = stack.pop();
+            result.add(removed.val);
+            if (removed.right != null) {
+                stack.push(removed.right);
             }
-            
-            if(curr.left != null) {
-                s.push(curr.left);
+            if (removed.left != null) {
+                stack.push(removed.left);
             }
         }
-        
-        return ans;
+        return result;
     }
 }

From c6424ab6674f7ebf8e91f7a5a6abc35df95cfc9d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 9 Jan 2023 15:17:52 -0800
Subject: [PATCH 1501/2175] Create Find Consecutive Integers from a Data
 Stream.java

---
 ...nsecutive Integers from a Data Stream.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Find Consecutive Integers from a Data Stream.java

diff --git a/Medium/Find Consecutive Integers from a Data Stream.java b/Medium/Find Consecutive Integers from a Data Stream.java
new file mode 100644
index 00000000..7f57b28d
--- /dev/null
+++ b/Medium/Find Consecutive Integers from a Data Stream.java	
@@ -0,0 +1,23 @@
+class DataStream {
+    
+    private int k;
+    private int value;
+    private int counter;
+
+    public DataStream(int value, int k) {
+        this.k = k;
+        this.value = value;
+        this.counter = 0;
+    }
+    
+    public boolean consec(int num) {
+        counter = value == num ? (counter + 1) : 0;
+        return counter >= k;
+    }
+}
+
+/**
+ * Your DataStream object will be instantiated and called as such:
+ * DataStream obj = new DataStream(value, k);
+ * boolean param_1 = obj.consec(num);
+ */

From 48e25e725edbaaf7fe10c72071a978ed3b98629b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 13 Jan 2023 07:54:35 -0800
Subject: [PATCH 1502/2175] Create Maximal Score After Applying K
 Operations.java

---
 ...Maximal Score After Applying K Operations.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Maximal Score After Applying K Operations.java

diff --git a/Medium/Maximal Score After Applying K Operations.java b/Medium/Maximal Score After Applying K Operations.java
new file mode 100644
index 00000000..ca776caf
--- /dev/null
+++ b/Medium/Maximal Score After Applying K Operations.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public long maxKelements(int[] nums, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        for (int num : nums) {
+            pq.add(num);
+        }
+        long sum = 0;
+        while (!pq.isEmpty() && k-- > 0) {
+            int removed = pq.poll();
+            sum += removed;
+            pq.add((int) Math.ceil(((double) removed) / 3));
+        }
+        return sum;
+    }
+}

From 62a78b3aff64a78ca71d7be3a7ab14b1deb50ad2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 13 Jan 2023 16:14:26 -0800
Subject: [PATCH 1503/2175] Update Number of Nodes in the Sub-Tree With the
 Same Label.java

---
 ...s in the Sub-Tree With the Same Label.java | 50 +++++++++----------
 1 file changed, 24 insertions(+), 26 deletions(-)

diff --git a/Medium/Number of Nodes in the Sub-Tree With the Same Label.java b/Medium/Number of Nodes in the Sub-Tree With the Same Label.java
index 473b9052..1798a058 100644
--- a/Medium/Number of Nodes in the Sub-Tree With the Same Label.java	
+++ b/Medium/Number of Nodes in the Sub-Tree With the Same Label.java	
@@ -1,30 +1,28 @@
 class Solution {
-  public int[] countSubTrees(int n, int[][] edges, String labels) {
-    Map<Integer, List<Integer>> map = new HashMap<>();
-    for (int[] edge : edges) {
-      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
-      map.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
-    }
-    int[] count = new int[n];
-    Set<Integer> set = new HashSet<>();
-    dfs(map, 0, labels, count, set);
-    return count;
-  }
-  
-  private int[] dfs(Map<Integer, List<Integer>> map, int curr, String labels, int[] count, Set<Integer> set) {
-    int[] cnt = new int[26];
-    if (set.add(curr)) {
-      char c = labels.charAt(curr);
-      for (Integer child : map.getOrDefault(curr, new ArrayList<>())) {
-        int[] temp = dfs(map, child, labels, count, set);
-        for (int i = 0; i < 26; i++) {
-          cnt[i] += temp[i];
+    public int[] countSubTrees(int n, int[][] edges, String labels) {
+        Map<Integer, List<Integer>> tree = new HashMap<>();
+        for (int[] edge : edges) {
+            tree.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            tree.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+        }
+        int[] result = new int[n];
+        Set<Integer> visited = new HashSet<>();
+        bfs(tree, 0, labels, result, visited);
+        return result;
+    } 
+    
+    private int[] bfs(Map<Integer, List<Integer>> tree, int currNode, String labels, int[] result, Set<Integer> visited) {
+        int[] labelCount = new int[26];
+        if (visited.add(currNode)) {
+            labelCount[labels.charAt(currNode) - 'a']++;
+            for (Integer child : tree.getOrDefault(currNode, new ArrayList<>())) {
+                int[] childLabelCount = bfs(tree, child, labels, result, visited);
+                for (int i = 0; i < 26; i++) {
+                    labelCount[i] += childLabelCount[i];
+                }
+            }
+            result[currNode] += labelCount[labels.charAt(currNode) - 'a'];
         }
-      }
-      cnt[c - 'a']++;
-      count[curr] = cnt[c - 'a'];
+        return labelCount;
     }
-    return cnt;
-  }
 }
-

From 624e04a5d4bf97cd2769e8bf938a967ee9d7574e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 15 Jan 2023 07:42:33 -0800
Subject: [PATCH 1504/2175] Create Difference Between Element Sum and Digit Sum
 of an Array.java

---
 ...Element Sum and Digit Sum of an Array.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Difference Between Element Sum and Digit Sum of an Array.java

diff --git a/Easy/Difference Between Element Sum and Digit Sum of an Array.java b/Easy/Difference Between Element Sum and Digit Sum of an Array.java
new file mode 100644
index 00000000..1aef4cbe
--- /dev/null
+++ b/Easy/Difference Between Element Sum and Digit Sum of an Array.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int differenceOfSum(int[] nums) {
+        int elementSum = 0;
+        int digitSum = 0;
+        for (int num : nums) {
+            elementSum += num;
+            digitSum += getDigitSum(num);
+        }
+        return Math.abs(elementSum - digitSum);
+    }
+    
+    private static int getDigitSum(int num) {
+        int sum = 0;
+        while (num > 0) {
+            sum += num % 10;
+            num /= 10;
+        }
+        return sum;
+    }
+}

From 90a64d0a37ed431611cbf2ea17d630c4f83f5afb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 20 Jan 2023 15:12:58 -0800
Subject: [PATCH 1505/2175] Update Duplicate Zeros.java

---
 Easy/Duplicate Zeros.java | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/Easy/Duplicate Zeros.java b/Easy/Duplicate Zeros.java
index 54a3592a..9f97be38 100644
--- a/Easy/Duplicate Zeros.java	
+++ b/Easy/Duplicate Zeros.java	
@@ -1,23 +1,23 @@
 class Solution {
-  public void duplicateZeros(int[] arr) {
-    int numOfZeros = 0;
-    for (int num : arr) {
-      numOfZeros += num == 0 ? 1 : 0;
+    public void duplicateZeros(int[] arr) {
+        int count = 0;
+        for (int i = 0; i < arr.length; i++) {
+            count += arr[i] == 0 ? 1 : 0;
+        }
+        int idxOne = arr.length - 1;
+        int idxTwo = arr.length + count - 1;
+        while (idxOne != idxTwo) {
+            insertAtEnd(arr, idxOne, idxTwo--);
+            if (arr[idxOne] == 0) {
+                insertAtEnd(arr, idxOne, idxTwo--);
+            }
+            idxOne--;
+        }
     }
-    int i = arr.length - 1;
-    int j = arr.length + numOfZeros - 1;
-    while (i != j) {
-      insert(arr, i, j--);
-      if (arr[i] == 0) {
-        insert(arr, i, j--);
-      }
-      i--;
+    
+    private void insertAtEnd(int[] arr, int idxOne, int idxTwo) {
+        if (idxTwo < arr.length) {
+            arr[idxTwo] = arr[idxOne];
+        }
     }
-  }
-  
-  private void insert(int[] arr, int i, int j) {
-    if (j < arr.length) {
-      arr[j] = arr[i];
-    }
-  }
 }

From 3d6bf009a611de4148b75486de8943b64ae803ab Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 21 Jan 2023 11:00:35 -0800
Subject: [PATCH 1506/2175] Create Minimum Common Value.java

---
 Easy/Minimum Common Value.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Minimum Common Value.java

diff --git a/Easy/Minimum Common Value.java b/Easy/Minimum Common Value.java
new file mode 100644
index 00000000..5062e9a3
--- /dev/null
+++ b/Easy/Minimum Common Value.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int getCommon(int[] nums1, int[] nums2) {
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < nums1.length && idxTwo < nums2.length) {
+            if (nums1[idxOne] < nums2[idxTwo]) {
+                idxOne++;
+            } else if (nums2[idxTwo] < nums1[idxOne]) {
+                idxTwo++;
+            } else {
+                return nums1[idxOne];
+            }
+        }
+        return -1;
+    }
+}

From 7a9b3a761ee43e2cb1a685bd42bc637ee70c4442 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 22 Jan 2023 07:22:28 -0800
Subject: [PATCH 1507/2175] Create Alternating Digit Sum.java

---
 Easy/Alternating Digit Sum.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Alternating Digit Sum.java

diff --git a/Easy/Alternating Digit Sum.java b/Easy/Alternating Digit Sum.java
new file mode 100644
index 00000000..4505e2e3
--- /dev/null
+++ b/Easy/Alternating Digit Sum.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int alternateDigitSum(int n) {
+        int firstHalf = 0;
+        int secondHalf = 0;
+        int count = 0;
+        while (n > 0) {
+            secondHalf += n % 10;
+            n /= 10;
+            count++;
+            if (n > 0) {
+                firstHalf += n % 10;
+                n /= 10;
+                count++;
+            }
+        }
+        return count % 2 == 0 ? (firstHalf + -1 * secondHalf) : (secondHalf + -1 * firstHalf);
+    }
+}

From 7cf358c7e57a4ed4395a36dbccd4887cbb008f85 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 Jan 2023 09:21:19 -0800
Subject: [PATCH 1508/2175] Create Sort the Students by Their Kth Score.java

---
 Medium/Sort the Students by Their Kth Score.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Medium/Sort the Students by Their Kth Score.java

diff --git a/Medium/Sort the Students by Their Kth Score.java b/Medium/Sort the Students by Their Kth Score.java
new file mode 100644
index 00000000..7c4f83e9
--- /dev/null
+++ b/Medium/Sort the Students by Their Kth Score.java	
@@ -0,0 +1,6 @@
+class Solution {
+    public int[][] sortTheStudents(int[][] score, int k) {
+        Arrays.sort(score, (o1, o2) -> o2[k] - o1[k]);
+        return score;
+    }
+}

From cd0f908dc1d656cfa78277a5b3c730bfee750902 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 25 Jan 2023 07:20:35 -0800
Subject: [PATCH 1509/2175] Create Find Closest Node to Given Two Nodes.java

---
 .../Find Closest Node to Given Two Nodes.java | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 Medium/Find Closest Node to Given Two Nodes.java

diff --git a/Medium/Find Closest Node to Given Two Nodes.java b/Medium/Find Closest Node to Given Two Nodes.java
new file mode 100644
index 00000000..4c68c333
--- /dev/null
+++ b/Medium/Find Closest Node to Given Two Nodes.java	
@@ -0,0 +1,40 @@
+class Solution {
+    public int closestMeetingNode(int[] edges, int node1, int node2) {
+        int n = edges.length;
+        int[] distance1 = new int[n];
+        int[] distance2 = new int[n];
+        Arrays.fill(distance1, Integer.MAX_VALUE);
+        Arrays.fill(distance2, Integer.MAX_VALUE);
+        bfs(node1, edges, distance1);
+        bfs(node2, edges, distance2);
+        int minDistanceNode = -1;
+        int currMinDistance = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (currMinDistance > Math.max(distance1[i], distance2[i])) {
+                minDistanceNode = i;
+                currMinDistance = Math.max(distance1[i], distance2[i]);
+            }
+        }
+        return minDistanceNode;
+    }
+    
+    private void bfs(int startNode, int[] edges, int[] distance) {
+        int n = edges.length;
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(startNode);
+        boolean[] visited = new boolean[n];
+        distance[startNode] = 0;
+        while (!queue.isEmpty()) {
+            int node = queue.remove();
+            if (visited[node]) {
+                continue;
+            }
+            visited[node] = true;
+            int neighbor = edges[node];
+            if (neighbor != -1 && !visited[neighbor]) {
+                distance[neighbor] = 1 + distance[node];
+                queue.add(neighbor);
+            }
+        }
+    }
+}

From f79aa6c69435885fa989c69475a03565e89cdb8c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 Jan 2023 10:24:06 -0800
Subject: [PATCH 1510/2175] Create Cheapest Flights Within K Stops.java

---
 Medium/Cheapest Flights Within K Stops.java | 32 +++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Cheapest Flights Within K Stops.java

diff --git a/Medium/Cheapest Flights Within K Stops.java b/Medium/Cheapest Flights Within K Stops.java
new file mode 100644
index 00000000..e937fdaf
--- /dev/null
+++ b/Medium/Cheapest Flights Within K Stops.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+        Map<Integer, List<int[]>> graph = new HashMap<>();
+        for (int[] flight : flights) {
+            graph.computeIfAbsent(flight[0], ArrayList::new).add(new int[]{flight[1], flight[2]});
+        }
+        int[] price = new int[n];
+        Arrays.fill(price, Integer.MAX_VALUE);
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{src, 0});
+        while (k-- >= 0 && !queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                int currCity = removed[0];
+                int currPrice = removed[1];
+                if (!graph.containsKey(currCity)) {
+                    continue;
+                }
+                for (int[] node : graph.get(currCity)) {
+                    int nextCity = node[0];
+                    int flightPrice = node[1];
+                    if (currPrice + flightPrice < price[nextCity]) {
+                        price[nextCity] = currPrice + flightPrice;
+                        queue.add(new int[]{nextCity, price[nextCity]});
+                    }
+                }
+            }
+        }
+        return price[dst] == Integer.MAX_VALUE ? -1 : price[dst];
+    }
+}

From 05bfdaadb040e1c68d26c1330d3c8f6957ed4f29 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 28 Jan 2023 08:57:17 -0800
Subject: [PATCH 1511/2175] Create Minimum Health to Beat Game.java

---
 Medium/Minimum Health to Beat Game.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Minimum Health to Beat Game.java

diff --git a/Medium/Minimum Health to Beat Game.java b/Medium/Minimum Health to Beat Game.java
new file mode 100644
index 00000000..9b93099e
--- /dev/null
+++ b/Medium/Minimum Health to Beat Game.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public long minimumHealth(int[] damage, int armor) {
+        int maxDamage = 0;
+        long totalDamage = 0;
+        for (int d : damage) {
+            totalDamage += d;
+            maxDamage = Math.max(maxDamage, d);
+        }
+        return totalDamage - Math.min(armor, maxDamage) + 1;
+    }
+}

From 53169adafa0de5cb98c80b743910af00afdd9053 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 29 Jan 2023 08:03:55 -0800
Subject: [PATCH 1512/2175] Update LFU Cache.java

---
 Hard/LFU Cache.java | 209 +++++++++++++++++++++++---------------------
 1 file changed, 111 insertions(+), 98 deletions(-)

diff --git a/Hard/LFU Cache.java b/Hard/LFU Cache.java
index 4d52ade6..d4caef70 100644
--- a/Hard/LFU Cache.java	
+++ b/Hard/LFU Cache.java	
@@ -1,112 +1,125 @@
 class LFUCache {
 
-  private final Map<Integer, Node> keyToNodeMap;
-  private final Map<Integer, Node[]> frequencyToNodeMap;
-  private final Map<Integer, Integer> keyToFrequencyMap;
-  private int capacity;
-  private int currentCapacity;
-
-  public LFUCache(int capacity) {
-    this.capacity = capacity;
-    this.currentCapacity = 0;
-    this.keyToNodeMap = new HashMap<>();
-    this.frequencyToNodeMap = new TreeMap<>();
-    this.keyToFrequencyMap = new HashMap<>();
-  }
-
-  public int get(int key) {
-    if (!keyToNodeMap.containsKey(key)) {
-      return -1;
+    private final TreeMap<Integer, NodeLinkedList> frequencyToNodeMap;
+    private final Map<Integer, Node> keyToNodeMap;
+    private final int capacity;
+
+    public LFUCache(int capacity) {
+        this.frequencyToNodeMap = new TreeMap<>();
+        this.keyToNodeMap = new HashMap<>();
+        this.capacity = capacity;
+    }
+
+    public int get(int key) {
+        if (!keyToNodeMap.containsKey(key)) {
+            return -1;
+        }
+        Node node = keyToNodeMap.get(key);
+        updateNodeForFrequencyChange(node);
+        return node.value;
     }
-    Node node = keyToNodeMap.get(key);
-    removeNode(node);
-    int currentFrequency = keyToFrequencyMap.get(key);
-    int newFrequency = currentFrequency + 1;
-    keyToFrequencyMap.put(key, newFrequency);
-    addNodeToFrequencyHead(node, newFrequency);
-    return node.val;
-  }
-
-  public void put(int key, int value) {
-    if (this.capacity == 0) {
-      return;
+
+    public void put(int key, int value) {
+        if (this.keyToNodeMap.containsKey(key)) {
+            updateNode(key, value);
+        } else {
+            addNewNode(key, value);
+        }
     }
-    removeNodeIfCapacityReached(key);
-    Node node = getNode(key, value);
-    int newFrequency = keyToFrequencyMap.getOrDefault(key, 0) + 1;
-    keyToFrequencyMap.put(key, newFrequency);
-    keyToNodeMap.put(key, node);
-    if (newFrequency > 1) {
-      removeNode(node);
+
+    private void updateNode(int key, int value) {
+        Node node = keyToNodeMap.get(key);
+        node.value = value;
+        updateNodeForFrequencyChange(node);
     }
-    addNodeToFrequencyHead(node, newFrequency);
-  }
-
-  private void removeNodeIfCapacityReached(int key) {
-    if (!keyToNodeMap.containsKey(key) && this.currentCapacity == capacity) {
-      for (Integer freq : frequencyToNodeMap.keySet()) {
-        Node[] nodes = frequencyToNodeMap.get(freq);
-        if (nodes[1].prev.val == -1) {
-          continue;
+
+    private void addNewNode(int key, int value) {
+        if (capacity == 0) {
+            return;
+        }
+        if (capacity == keyToNodeMap.size()) {
+            evictCache();
+        }
+        Node node = new Node(key, value);
+        addToFrequencyMap(node);
+        keyToNodeMap.put(key, node);
+    }
+
+    private void evictCache() {
+        int firstKey = frequencyToNodeMap.firstKey();
+        Node nodeToEvict = frequencyToNodeMap.get(firstKey).getFirstNode();
+        removeNode(nodeToEvict);
+        keyToNodeMap.remove(nodeToEvict.key);
+        if (frequencyToNodeMap.get(firstKey).getFirstNode().value == -1) {
+            frequencyToNodeMap.remove(firstKey);
+        }
+    }
+
+    private void updateNodeForFrequencyChange(Node node) {
+        int prevFrequency = node.frequency;
+        node.frequency = node.frequency + 1;
+        removeNode(node);
+        if (frequencyToNodeMap.get(prevFrequency).getFirstNode().value == -1) {
+            frequencyToNodeMap.remove(prevFrequency);
         }
-        Node toRemove = nodes[1].prev;
-        removeNode(toRemove);
-        keyToNodeMap.remove(toRemove.key);
-        keyToFrequencyMap.remove(toRemove.key);
-        this.currentCapacity--;
-        break;
-      }
+        addToFrequencyMap(node);
     }
-  }
-
-  private Node getNode(int key, int value) {
-    Node node;
-    if (keyToNodeMap.containsKey(key)) {
-      node = keyToNodeMap.get(key);
-      removeNode(node);
-      node.val = value;
-    } else {
-      this.currentCapacity++;
-      node = new Node(value, key);
+
+    private void removeNode(Node node) {
+        Node prevToNode = node.prev;
+        Node nextToNode = node.next;
+        prevToNode.next = nextToNode;
+        nextToNode.prev = prevToNode;
     }
-    return node;
-  }
-
-  private void addNodeToFrequencyHead(Node node, int newFrequency) {
-    if (!frequencyToNodeMap.containsKey(newFrequency)) {
-      Node head = new Node(-1, Integer.MIN_VALUE);
-      Node tail = new Node(-1, Integer.MAX_VALUE);
-      head.next = tail;
-      tail.prev = head;
-      frequencyToNodeMap.put(newFrequency, new Node[]{head, tail});
+
+    private void addToFrequencyMap(Node node) {
+        if (!frequencyToNodeMap.containsKey(node.frequency)) {
+            frequencyToNodeMap.put(node.frequency, new NodeLinkedList());
+        }
+        frequencyToNodeMap.get(node.frequency).addNode(node);
     }
-    Node headNode = frequencyToNodeMap.get(newFrequency)[0];
-    Node nextToHead = headNode.next;
-    nextToHead.prev = node;
-    node.next = nextToHead;
-    headNode.next = node;
-    node.prev = headNode;
-  }
-  
-  private void removeNode(Node node) {
-    Node prevNode = node.prev;
-    Node nextNode = node.next;
-    prevNode.next = nextNode;
-    nextNode.prev = prevNode;
-  }
-
-  private static class Node {
-    int val;
-    int key;
-    Node next;
-    Node prev;
-
-    public Node(int val, int key) {
-      this.val = val;
-      this.key = key;
+
+    private static class NodeLinkedList {
+        private final Node head;
+        private final Node tail;
+
+        public NodeLinkedList() {
+            this.head = new Node(-1, -1);
+            this.tail = new Node(-1, -1);
+            head.next = tail;
+            tail.prev = head;
+        }
+
+        public Node getFirstNode() {
+            return head.next;
+        }
+
+        public void addNode(Node node) {
+            Node prevToTail = tail.prev;
+            node.prev = prevToTail;
+            prevToTail.next = node;
+            node.next = tail;
+            tail.prev = node;
+        }
+    }
+
+    private static class Node {
+        private final int key;
+        private int value;
+        private int frequency;
+        private Node next;
+        private Node prev;
+
+        public Node(int key, int value) {
+            this.key = key;
+            this.value = value;
+            this.frequency = 1;
+            this.next = null;
+            this.prev = null;
+        }
     }
-  }
 }
+
 /**
  * Your LFUCache object will be instantiated and called as such:
  * LFUCache obj = new LFUCache(capacity);

From 31dc4a0798c5265f6be9f3c86a8f712677e0ec29 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 31 Jan 2023 09:34:06 -0800
Subject: [PATCH 1513/2175] Create Count Distinct Numbers on Board.java

---
 Easy/Count Distinct Numbers on Board.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Count Distinct Numbers on Board.java

diff --git a/Easy/Count Distinct Numbers on Board.java b/Easy/Count Distinct Numbers on Board.java
new file mode 100644
index 00000000..42a7ad68
--- /dev/null
+++ b/Easy/Count Distinct Numbers on Board.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int distinctIntegers(int n) {
+        return Math.max(n - 1, 1);
+    }
+}

From e5b2cf9e87f8d6d9b2af971a8a7b85b6e1d7da8c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 31 Jan 2023 19:33:57 -0800
Subject: [PATCH 1514/2175] Update Greatest Common Divisor of Strings.java

---
 Easy/Greatest Common Divisor of Strings.java | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/Easy/Greatest Common Divisor of Strings.java b/Easy/Greatest Common Divisor of Strings.java
index 263b6caa..f817725a 100644
--- a/Easy/Greatest Common Divisor of Strings.java	
+++ b/Easy/Greatest Common Divisor of Strings.java	
@@ -1,13 +1,13 @@
 class Solution {
-  public String gcdOfStrings(String str1, String str2) {
-    if (str1.length() < str2.length()) {  
-      return gcdOfStrings(str2, str1); 
-    } else if (!str1.startsWith(str2)) {
-      return "";
-    } else if (str2.isEmpty()) { 
-      return str1;
-    } else { 
-      return gcdOfStrings(str1.substring(str2.length()), str2); 
+    public String gcdOfStrings(String str1, String str2) {
+        if (!(str1 + str2).equals(str2 + str1)) {
+            return "";
+        }
+        int gcdLength = gcd(str1.length(), str2.length());
+        return str1.substring(0, gcdLength);
+    }
+    
+    private int gcd(int x, int y) {
+        return y == 0 ? x : gcd(y, x % y);
     }
-  }
 }

From 4b9a51fdb0b1e94b07a03039eb29024aea14b456 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Feb 2023 16:17:33 -0800
Subject: [PATCH 1515/2175] Update Verifying an Alien Dictionary.java

---
 Easy/Verifying an Alien Dictionary.java | 46 ++++++++++++-------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/Easy/Verifying an Alien Dictionary.java b/Easy/Verifying an Alien Dictionary.java
index e11a4728..08bf111e 100644
--- a/Easy/Verifying an Alien Dictionary.java	
+++ b/Easy/Verifying an Alien Dictionary.java	
@@ -1,27 +1,27 @@
 class Solution {
-  public boolean isAlienSorted(String[] words, String order) {
-    Map<Character, Integer> map = new HashMap<>();
-    int idx = 0;
-    for (char c : order.toCharArray()) {
-      map.put(c, idx++);
-    }
-    for (int i = 1; i < words.length; i++) {
-      if (!isSorted(words[i - 1], words[i], map)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  
-  private boolean isSorted(String wordOne, String wordTwo, Map<Character, Integer> map) {
-    for (int i = 0; i < Math.min(wordOne.length(), wordTwo.length()); i++) {
-      int diff = map.get(wordOne.charAt(i)) - map.get(wordTwo.charAt(i));
-      if (diff > 0) {
-        return false;
-      } else if (diff < 0) {
+    public boolean isAlienSorted(String[] words, String order) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < order.length(); i++) {
+            map.put(order.charAt(i), i);
+        }
+        for (int i = 0; i < words.length - 1; i++) {
+            if (!inOrder(words[i], words[i + 1], map)) {
+                return false;
+            }
+        }
         return true;
-      }
     }
-    return wordOne.length() <= wordTwo.length();
-  }
+    
+    private static boolean inOrder(String wordOne, String wordTwo, Map<Character, Integer> map) {
+        for (int i = 0; i < Math.min(wordOne.length(), wordTwo.length()); i++) {
+            int diff = map.get(wordOne.charAt(i)) - map.get(wordTwo.charAt(i));
+            if (diff < 0) {
+                return true;
+            }
+            if (diff > 0) {
+                return false;
+            }
+        }
+        return wordOne.length() <= wordTwo.length();
+    }
 }

From 938ce93e6cdd35b86c4fd07e51fba01ff59ebcd7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 2 Feb 2023 13:56:24 -0800
Subject: [PATCH 1516/2175] Update Subtree of Another Tree.java

---
 Easy/Subtree of Another Tree.java | 35 +++++++++++++------------------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/Easy/Subtree of Another Tree.java b/Easy/Subtree of Another Tree.java
index a88e3642..c0e307eb 100644
--- a/Easy/Subtree of Another Tree.java	
+++ b/Easy/Subtree of Another Tree.java	
@@ -14,26 +14,21 @@
  * }
  */
 class Solution {
-  public boolean isSubtree(TreeNode root, TreeNode subRoot) {
-    if (root == null) {
-      return false;
+    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
+        if (root == null) {
+            return false;
+        }
+        boolean result = root.val == subRoot.val && isSubtreeHelper(root, subRoot);
+        return result || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
     }
-    if (isSubtreeHelper(root, subRoot)) {
-      return true;
+    
+    private boolean isSubtreeHelper(TreeNode root, TreeNode subRoot) {
+        if (root == null && subRoot == null) {
+            return true;
+        }
+        if (root == null || subRoot == null) {
+            return false;
+        }
+        return root.val == subRoot.val && isSubtreeHelper(root.left, subRoot.left) && isSubtreeHelper(root.right, subRoot.right);
     }
-    return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
-  }
-  
-  private boolean isSubtreeHelper(TreeNode root, TreeNode subRoot) {
-    if (root == null && subRoot == null) {
-      return true;
-    }
-    if (root == null || subRoot == null) {
-      return false;
-    }
-    if (root.val != subRoot.val) {
-      return false;
-    }
-    return isSubtreeHelper(root.left, subRoot.left) && isSubtreeHelper(root.right, subRoot.right);
-  }
 }

From a625604af6f02e0390f75f6108f970c05d26d446 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 3 Feb 2023 08:20:13 -0800
Subject: [PATCH 1517/2175] Update ZigZag Conversion.java

---
 Medium/ZigZag Conversion.java | 48 +++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 22 deletions(-)

diff --git a/Medium/ZigZag Conversion.java b/Medium/ZigZag Conversion.java
index 62539da4..31793633 100644
--- a/Medium/ZigZag Conversion.java	
+++ b/Medium/ZigZag Conversion.java	
@@ -1,25 +1,29 @@
 class Solution {
-  public String convert(String s, int numRows) {
-    if (numRows == 1) {
-      return s;
+    public String convert(String s, int numRows) {
+        if (numRows == 1) {
+            return s;
+        }
+        StringBuilder[] rows = new StringBuilder[numRows];
+        for (int i = 0; i < numRows; i++) {
+            rows[i] = new StringBuilder();
+        }
+        int row = 0;
+        int n = s.length();
+        int idx = 0;
+        while (idx < n) {
+            while (idx < n && row < numRows) {
+                rows[row++].append(s.charAt(idx++));
+            }
+            row -= 2;
+            while (idx < n && row >= 0) {
+                rows[row--].append(s.charAt(idx++));
+            }
+            row += 2;
+        }
+        StringBuilder result = new StringBuilder();
+        for (StringBuilder sb : rows) {
+            result.append(sb.toString());
+        }
+        return result.toString();
     }
-    List<StringBuilder> list = new ArrayList<>();
-    for (int i = 0; i < numRows; i++) {
-      list.add(new StringBuilder());
-    }
-    int idx = 0;
-    boolean downDirection = false;
-    for (char c : s.toCharArray()) {
-      list.get(idx).append(c);
-      if (idx == 0 || idx == numRows - 1) {
-        downDirection = !downDirection;
-      }
-      idx += downDirection ? 1 : -1;
-    }
-    StringBuilder result = new StringBuilder();
-    for (StringBuilder sb : list) {
-      result.append(sb.toString());
-    }
-    return result.toString();
-  }
 }

From 9382e4c247c939f8fdcc65d312cd74f164929342 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 4 Feb 2023 12:38:17 -0800
Subject: [PATCH 1518/2175] Update Permutation in String.java

---
 Medium/Permutation in String.java | 62 +++++++++++++++++--------------
 1 file changed, 34 insertions(+), 28 deletions(-)

diff --git a/Medium/Permutation in String.java b/Medium/Permutation in String.java
index ff95424e..dd255290 100644
--- a/Medium/Permutation in String.java	
+++ b/Medium/Permutation in String.java	
@@ -1,32 +1,38 @@
 class Solution {
-  public boolean checkInclusion(String s1, String s2) {
-    if (s2.length() < s1.length()) {
-      return false;
-    }
-    int[] frequency = new int[26];
-    for (int i = 0; i < s1.length(); i++) {
-      frequency[s1.charAt(i) - 'a']++;
-      frequency[s2.charAt(i) - 'a']--;
-    }
-    if (allZeroArray(frequency)) {
-      return true;
-    }
-    for (int i = s1.length(); i < s2.length(); i++) {
-      frequency[s2.charAt(i) - 'a']--;
-      frequency[s2.charAt(i - s1.length()) - 'a']++;
-      if (allZeroArray(frequency)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  private boolean allZeroArray(int[] frequency) {
-    for (int count : frequency) {
-      if (count != 0) {
+    public boolean checkInclusion(String s1, String s2) {
+        if (s1.length() > s2.length()) {
+            return false;
+        }
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s1.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        int n = s1.length();
+        int[] count = {map.size()};
+        for (int i = 0; i < n - 1; i++) {
+            updateMap(map, s2.charAt(i), count, true);
+        }
+        int start = 0;
+        for (int i = n - 1; i < s2.length(); i++) {
+            updateMap(map, s2.charAt(i), count, true);
+            if (count[0] == 0) {
+                return true;
+            }
+            updateMap(map, s2.charAt(start++), count, false);
+        }
         return false;
-      }
     }
-    return true;
-  }
+    
+    private void updateMap(Map<Character, Integer> map, char c, int[] count, boolean decrement) {
+        if (map.containsKey(c)) {
+            int diff = decrement ? -1 : 1;
+            map.put(c, map.get(c) + diff);
+            if (decrement && map.get(c) == 0) {
+                count[0]--;
+            }
+            if (!decrement && map.get(c) == 1) {
+                count[0]++;
+            }
+        }
+    }
 }

From 532d5eb08cb2ee1c9c1cde71af78a29516d2ade3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 4 Feb 2023 17:32:09 -0800
Subject: [PATCH 1519/2175] Create Separate the Digits in an Array.java

---
 Easy/Separate the Digits in an Array.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Separate the Digits in an Array.java

diff --git a/Easy/Separate the Digits in an Array.java b/Easy/Separate the Digits in an Array.java
new file mode 100644
index 00000000..9bd6878f
--- /dev/null
+++ b/Easy/Separate the Digits in an Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int[] separateDigits(int[] nums) {
+        List<Integer> result = new ArrayList<>();
+        for (int num : nums) {
+            int startIdx = result.size();
+            while (num > 0) {
+                result.add(num % 10);
+                num /= 10;
+            }
+            int endIdx = result.size() - 1;
+            while (startIdx < endIdx) {
+                int temp = result.get(startIdx);
+                result.set(startIdx++, result.get(endIdx));
+                result.set(endIdx--, temp);
+            }
+        }
+        return result.stream().mapToInt(Integer::intValue).toArray();
+    }
+}

From de44f03a3fb7c986644554e147995415f204ad05 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 Feb 2023 09:17:44 -0800
Subject: [PATCH 1520/2175] Delete Find All Anagrams in a String.java

---
 Easy/Find All Anagrams in a String.java | 39 -------------------------
 1 file changed, 39 deletions(-)
 delete mode 100644 Easy/Find All Anagrams in a String.java

diff --git a/Easy/Find All Anagrams in a String.java b/Easy/Find All Anagrams in a String.java
deleted file mode 100644
index 8d79ab3b..00000000
--- a/Easy/Find All Anagrams in a String.java	
+++ /dev/null
@@ -1,39 +0,0 @@
-class Solution {
-    public static List<Integer> findAnagrams(String s, String p) {
-        List<Integer> indexes = new ArrayList<>();
-        Map<Character, Integer> pMap = new TreeMap<>();
-
-        for (char c : p.toCharArray()) {
-            pMap.put(c, pMap.getOrDefault(c, 0) + 1);
-        }
-
-        Map<Character, Integer> map = new TreeMap<>();
-
-        for (int i=0; i<p.length() && i<s.length(); i++) {
-            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
-        }
-
-        int i = p.length();
-        while (i < s.length()) {
-            int ind = i - p.length();         
-            if (map.toString().equals(pMap.toString())) {
-                indexes.add(ind);
-            }
-            
-            map.put(s.charAt(ind), map.getOrDefault(s.charAt(ind), 0) - 1);
-            if (map.get(s.charAt(ind)) <= 0) {
-                map.remove(s.charAt(ind));
-            }
-
-            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
-
-            i++;
-        }
-
-        if (map.toString().equals(pMap.toString())) {
-            indexes.add(i-p.length());
-        }
-
-        return indexes;
-    }
-}

From ce91f5858fa1ef983f5d944730d8968120c449fa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 Feb 2023 09:18:04 -0800
Subject: [PATCH 1521/2175] Update Find All Anagrams in a String.java

---
 Medium/Find All Anagrams in a String.java | 48 ++++++++++-------------
 1 file changed, 21 insertions(+), 27 deletions(-)

diff --git a/Medium/Find All Anagrams in a String.java b/Medium/Find All Anagrams in a String.java
index 1edba8c7..e18917da 100644
--- a/Medium/Find All Anagrams in a String.java	
+++ b/Medium/Find All Anagrams in a String.java	
@@ -1,30 +1,24 @@
 class Solution {
-  public List<Integer> findAnagrams(String s, String p) {
-    List<Integer> list = new ArrayList<>();
-    if (s.length() < p.length()) {
-      return list;
+    public List<Integer> findAnagrams(String s, String p) {
+        if (s.length() < p.length()) {
+            return new ArrayList<>();
+        }
+        List<Integer> result = new ArrayList<>();
+        int[] patternCounter = new int[26];
+        for (char c : p.toCharArray()) {
+            patternCounter[c - 'a']++;
+        }
+        int[] counter = new int[26];
+        int start = 0;
+        for (int i = 0; i < s.length(); i++) {
+            counter[s.charAt(i) - 'a']++;
+            if (i >= p.length() - 1) {
+                if (Arrays.equals(patternCounter, counter)) {
+                    result.add(start);
+                }
+                counter[s.charAt(start++) - 'a']--;
+            }
+        }
+        return result;
     }
-    int[] pArr = new int[26];
-    for (char c : p.toCharArray()) {
-      pArr[c - 'a']++;
-    }
-    String pStr = Arrays.toString(pArr);
-    int start = 0;
-    int end = 0;
-    int n = s.length();
-    int[] sArr = new int[26];
-    while (end < (p.length() - 1)) {
-      sArr[s.charAt(end) - 'a']++;
-      end++;
-    }
-    while (end < n) {
-      sArr[s.charAt(end) - 'a']++;
-      end++;
-      if (Arrays.toString(sArr).equals(pStr)) {
-        list.add(start);
-      }
-      sArr[s.charAt(start++) - 'a']--;
-    }
-    return list;
-  }
 }

From c61ec791cae1ce3acec4d2c1c42cc54d5a69d18c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 Feb 2023 09:24:35 -0800
Subject: [PATCH 1522/2175] Create Take Gifts From the Richest Pile.java

---
 Easy/Take Gifts From the Richest Pile.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Take Gifts From the Richest Pile.java

diff --git a/Easy/Take Gifts From the Richest Pile.java b/Easy/Take Gifts From the Richest Pile.java
new file mode 100644
index 00000000..ea754818
--- /dev/null
+++ b/Easy/Take Gifts From the Richest Pile.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public long pickGifts(int[] gifts, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        long totalGifts = 0;
+        for (int gift : gifts) {
+            pq.add(gift);
+            totalGifts += gift;
+        }
+        while (k-- > 0) {
+            int removedGift = pq.poll();
+            int remainingGift = (int) Math.sqrt(removedGift);
+            totalGifts -= removedGift - remainingGift;
+            pq.add(remainingGift);
+        }
+        return totalGifts;
+    }
+}

From 3986e088971911d98b392aca2374ff92d43b3290 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 Feb 2023 15:04:35 -0800
Subject: [PATCH 1523/2175] Create Count Vowel Strings in Ranges.java

---
 Medium/Count Vowel Strings in Ranges.java | 26 +++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Count Vowel Strings in Ranges.java

diff --git a/Medium/Count Vowel Strings in Ranges.java b/Medium/Count Vowel Strings in Ranges.java
new file mode 100644
index 00000000..8f836610
--- /dev/null
+++ b/Medium/Count Vowel Strings in Ranges.java	
@@ -0,0 +1,26 @@
+class Solution {
+    
+    public int[] vowelStrings(String[] words, int[][] queries) {
+        int[] counter = new int[words.length];
+        int currCounter = 0;
+        for (int i = 0; i < words.length; i++) {
+            String word = words[i];
+            if (isVowel(word.charAt(0)) && isVowel(word.charAt(word.length() - 1))) {
+                currCounter++;
+            }
+            counter[i] = currCounter;
+        }
+        int[] result = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            int left = queries[i][0];
+            int right = queries[i][1];
+            result[i] = counter[right];
+            result[i] -= left == 0 ? 0 : counter[left - 1];
+        }
+        return result;
+    }
+    
+    private static boolean isVowel(char c) {
+        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
+    }
+}

From efb2017407da2c52f7d34d7f9d781b48edbee60f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Feb 2023 07:16:42 -0800
Subject: [PATCH 1524/2175] Create Maximum Number of Integers to Choose From a
 Range I.java

---
 ...er of Integers to Choose From a Range I.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Maximum Number of Integers to Choose From a Range I.java

diff --git a/Medium/Maximum Number of Integers to Choose From a Range I.java b/Medium/Maximum Number of Integers to Choose From a Range I.java
new file mode 100644
index 00000000..8f3ad2ee
--- /dev/null
+++ b/Medium/Maximum Number of Integers to Choose From a Range I.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxCount(int[] banned, int n, int maxSum) {
+        int count = 0;
+        Set<Integer> bannedSet = Arrays.stream(banned).boxed().collect(Collectors.toSet());
+        for (int i = 1; i <= n && count < n; i++) {
+            if (bannedSet.contains(i)) {
+                continue;
+            }
+            if (maxSum - i < 0) {
+                break;
+            }
+            count++;
+            maxSum -= i;
+        }
+        return count;
+    }
+}

From 9df7f26ef218c97b9d2bc7d481410eff64d2c20c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 Feb 2023 19:13:28 -0800
Subject: [PATCH 1525/2175] Update Fruit Into Baskets.java

---
 Medium/Fruit Into Baskets.java | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/Medium/Fruit Into Baskets.java b/Medium/Fruit Into Baskets.java
index 79889371..937fbbe9 100644
--- a/Medium/Fruit Into Baskets.java	
+++ b/Medium/Fruit Into Baskets.java	
@@ -1,21 +1,21 @@
 class Solution {
-  public int totalFruit(int[] fruits) {
-    Map<Integer, Integer> map = new HashMap<>();
-    int startIdx = 0;
-    int endIdx = 0;
-    int n = fruits.length;
-    int maxPickedCount = 0;
-    while (endIdx < n) {
-      map.put(fruits[endIdx], map.getOrDefault(fruits[endIdx++], 0) + 1);
-      while (startIdx < endIdx && map.size() > 2) {
-        map.put(fruits[startIdx], map.get(fruits[startIdx]) - 1);
-        if (map.get(fruits[startIdx]) == 0) {
-          map.remove(fruits[startIdx]);
+    public int totalFruit(int[] fruits) {
+        int maximumFruits = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        int start = 0;
+        int end = 0;
+        while (end < fruits.length) {
+            map.put(fruits[end], map.getOrDefault(fruits[end], 0) + 1);
+            end++;
+            while (start < end && map.size() > 2) {
+                map.put(fruits[start], map.get(fruits[start]) - 1);
+                if (map.get(fruits[start]) == 0) {
+                    map.remove(fruits[start]);
+                }
+                start++;
+            }
+            maximumFruits = Math.max(maximumFruits, end - start);
         }
-        startIdx++;
-      }
-      maxPickedCount = Math.max(maxPickedCount, endIdx - startIdx);
+        return maximumFruits;
     }
-    return maxPickedCount;
-  }   
 }

From dd963fb55ab560527a37f106c8cdd9b7e0f729b3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Feb 2023 07:59:20 -0800
Subject: [PATCH 1526/2175] Update Moving Average from Data Stream.java

---
 Easy/Moving Average from Data Stream.java | 34 +++++++++++------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/Easy/Moving Average from Data Stream.java b/Easy/Moving Average from Data Stream.java
index e52fa84a..ec9dca5b 100644
--- a/Easy/Moving Average from Data Stream.java	
+++ b/Easy/Moving Average from Data Stream.java	
@@ -1,23 +1,23 @@
 class MovingAverage {
-  
-  private int currSum;
-  private Queue<Integer> queue;
-  private int size;
-  
-  public MovingAverage(int size) {
-    this.currSum = 0;
-    this.size = size;
-    this.queue = new LinkedList<>();
-  }
 
-  public double next(int val) {
-    this.queue.add(val);
-    this.currSum += val;
-    if (this.queue.size() > this.size) {
-      this.currSum -= this.queue.remove();
+    private final Queue<Integer> queue;
+    private double currSum;
+    private final int size;
+    
+    public MovingAverage(int size) {
+        this.queue = new LinkedList<>();
+        this.currSum = 0;
+        this.size = size;
+    }
+    
+    public double next(int val) {
+        this.queue.add(val);
+        this.currSum += val;
+        if (this.queue.size() > this.size) {
+            this.currSum -= this.queue.remove();
+        }
+        return this.currSum / this.queue.size();
     }
-    return ((double) this.currSum) / this.queue.size();
-  }
 }
 
 /**

From d8c193280da25404d9ac9f4d29cfca00843b7f1b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Feb 2023 15:28:38 -0800
Subject: [PATCH 1527/2175] Update Print FooBar Alternately.java

---
 Concurrency/Print FooBar Alternately.java | 53 ++++++++++++-----------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/Concurrency/Print FooBar Alternately.java b/Concurrency/Print FooBar Alternately.java
index f19a774f..94fa19cc 100644
--- a/Concurrency/Print FooBar Alternately.java	
+++ b/Concurrency/Print FooBar Alternately.java	
@@ -1,32 +1,33 @@
 class FooBar {
-  private int n;
-
-  private Semaphore fooSemaphore = new Semaphore(1);
-  private Semaphore barSemaphore = new Semaphore(0);
-
-  public FooBar(int n) {
-    this.n = n;
-  }
-
-  public void foo(Runnable printFoo) throws InterruptedException {
-
-    for (int i = 0; i < n; i++) {
-
-      // printFoo.run() outputs "foo". Do not change or remove this line.
-      fooSemaphore.acquire();
-      printFoo.run();
-      barSemaphore.release();
+    private int n;
+    
+    private final Semaphore fooMutex;
+    private final Semaphore barMutex;
+
+    public FooBar(int n) {
+        this.n = n;
+        this.fooMutex = new Semaphore(1);
+        this.barMutex = new Semaphore(0);
     }
-  }
-
-  public void bar(Runnable printBar) throws InterruptedException {
 
-    for (int i = 0; i < n; i++) {
+    public void foo(Runnable printFoo) throws InterruptedException {
+        
+        for (int i = 0; i < n; i++) {
+            
+        	// printFoo.run() outputs "foo". Do not change or remove this line.
+            this.fooMutex.acquire();
+        	printFoo.run();
+            this.barMutex.release();
+        }
+    }
 
-      // printBar.run() outputs "bar". Do not change or remove this line.
-      barSemaphore.acquire();
-      printBar.run();
-      fooSemaphore.release();
+    public void bar(Runnable printBar) throws InterruptedException {
+        
+        for (int i = 0; i < n; i++) {
+            this.barMutex.acquire();
+            // printBar.run() outputs "bar". Do not change or remove this line.
+        	printBar.run();
+            this.fooMutex.release();
+        }
     }
-  }
 }

From 480f89b337836a264757186757a99ab02813a3f5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Feb 2023 07:34:32 -0800
Subject: [PATCH 1528/2175] Create Jump Game II.java

---
 Medium/Jump Game II.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Jump Game II.java

diff --git a/Medium/Jump Game II.java b/Medium/Jump Game II.java
new file mode 100644
index 00000000..0f3a792c
--- /dev/null
+++ b/Medium/Jump Game II.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int jump(int[] nums) {
+        int jumpCount = 0;
+        int left = 0;
+        int right = 0;
+        while (right < nums.length - 1) {
+            int farthest = 0;
+            for (int i = left; i <= right; i++) {
+                farthest = Math.max(farthest, i + nums[i]);
+            }
+            left = right + 1;
+            right = farthest;
+            jumpCount++;
+        }
+        return jumpCount;
+    }
+}

From fe1871836b77d554ab4138ae0c14cbcbd0a8d42e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Feb 2023 09:15:01 -0800
Subject: [PATCH 1529/2175] Update Wiggle Sort.java

---
 Medium/Wiggle Sort.java | 27 +++++++--------------------
 1 file changed, 7 insertions(+), 20 deletions(-)

diff --git a/Medium/Wiggle Sort.java b/Medium/Wiggle Sort.java
index e4e8ad13..68cac74b 100644
--- a/Medium/Wiggle Sort.java	
+++ b/Medium/Wiggle Sort.java	
@@ -1,24 +1,11 @@
 class Solution {
-  public void wiggleSort(int[] nums) {
-    boolean small = true;
-    for (int i = 0; i < nums.length - 1; i++) {
-      if (small) {
-        if (nums[i] > nums[i + 1]) {
-          swap(nums, i, i + 1);
+    public void wiggleSort(int[] nums) {
+        for (int i = 1; i < nums.length; i++) {
+            if ((i % 2 == 1 && nums[i] < nums[i - 1]) || (i % 2 != 1 && nums[i] > nums[i - 1])) {
+                int temp = nums[i];
+                nums[i] = nums[i - 1];
+                nums[i - 1] = temp;
+            } 
         }
-      }
-      else {
-        if (nums[i] < nums[i + 1]) {
-          swap(nums, i, i + 1);
-        }
-      }
-      small = !small;
     }
-  }
-  
-  private void swap(int[] nums, int idx1, int idx2) {
-    int temp = nums[idx2];
-    nums[idx2] = nums[idx1];
-    nums[idx1] = temp;
-  }
 }

From b26a7663e960de9519cbc98871856baad532aa88 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Feb 2023 19:34:52 -0800
Subject: [PATCH 1530/2175] Create Naming a Company.java

---
 Hard/Naming a Company.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Hard/Naming a Company.java

diff --git a/Hard/Naming a Company.java b/Hard/Naming a Company.java
new file mode 100644
index 00000000..c24f78fe
--- /dev/null
+++ b/Hard/Naming a Company.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public long distinctNames(String[] ideas) {
+        Map<Character, Set<String>> map = new HashMap<>();
+        for (String idea : ideas) {
+            map.computeIfAbsent(idea.charAt(0), k -> new HashSet<>()).add(idea.substring(1, idea.length()));
+        }
+        long result = 0;
+        for (Character key1 : map.keySet()) {
+            for (Character key2 : map.keySet()) {
+                if (key1 == key2) {
+                    continue;
+                }
+                int intersection = 0;
+                for (String word : map.get(key1)) {
+                    if (map.get(key2).contains(word)) {
+                        intersection++;
+                    }
+                }
+                int distinctOne = map.get(key1).size() - intersection;
+                int distinctTwo = map.get(key2).size() - intersection;
+                result += distinctOne * distinctTwo;
+            }    
+        }
+        return result;
+    }
+}

From 6e03310edaf59a802d56843c9be946c608a610d1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Feb 2023 07:47:26 -0800
Subject: [PATCH 1531/2175] Update Buddy Strings.java

---
 Easy/Buddy Strings.java | 57 +++++++++++++++++++----------------------
 1 file changed, 27 insertions(+), 30 deletions(-)

diff --git a/Easy/Buddy Strings.java b/Easy/Buddy Strings.java
index e153e52d..83f94a5a 100644
--- a/Easy/Buddy Strings.java	
+++ b/Easy/Buddy Strings.java	
@@ -1,36 +1,33 @@
 class Solution {
-  public boolean buddyStrings(String s, String goal) {
-    if (s.length() != goal.length()) {
-      return false;
-    }
-    if (s.equals(goal)) {
-      Set<Character> set = new HashSet<>();
-      for (char c : s.toCharArray()) {
-        if (set.contains(c)) {
-          return true;
+    public boolean buddyStrings(String s, String goal) {
+        if (s.length() != goal.length()) {
+            return false;
         }
-        set.add(c);
-      }
-      return false;
-    }
-    char[] mismatch = {'-', '-'};
-    for (int i = 0; i < s.length(); i++) {
-      if (s.charAt(i) != goal.charAt(i)) {
-        if (mismatch[0] == '|') {
-          return false;
+        int mismatchIdx = -1;
+        Set<Character> set = new HashSet<>();
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) != goal.charAt(i)) {
+                if (mismatchIdx == Integer.MAX_VALUE) {
+                    return false;
+                }
+                if (mismatchIdx == -1) {
+                    mismatchIdx = i;
+                } else {
+                    if (!(s.charAt(mismatchIdx) == goal.charAt(i) && s.charAt(i) == goal.charAt(mismatchIdx))) {
+                        return false;
+                    }
+                    mismatchIdx = Integer.MAX_VALUE;
+                }
+            } else {
+                set.add(s.charAt(i));
+            }
+        }
+        if (mismatchIdx != -1 && mismatchIdx != Integer.MAX_VALUE) {
+            return false;
         }
-        if (mismatch[0] == '-') {
-          mismatch[0] = s.charAt(i);
-          mismatch[1] = goal.charAt(i);
-        } else {
-          if (goal.charAt(i) == mismatch[0] && s.charAt(i) == mismatch[1]) {
-            mismatch[0] = '|';
-            continue;
-          }
-          return false;
+        if (mismatchIdx == -1) {
+            return s.length() > set.size();
         }
-      }
+        return true;
     }
-    return mismatch[0] == '|';
-  }
 }

From b6ff432749cbebdce0a67a16c8df8b02adbc170f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Feb 2023 09:46:15 -0800
Subject: [PATCH 1532/2175] Update Partition Labels.java

---
 Medium/Partition Labels.java | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/Medium/Partition Labels.java b/Medium/Partition Labels.java
index d8896c4a..e3157703 100644
--- a/Medium/Partition Labels.java	
+++ b/Medium/Partition Labels.java	
@@ -1,19 +1,19 @@
 class Solution {
-  public List<Integer> partitionLabels(String s) {
-    Map<Character, Integer> lastIndex = new HashMap<>();
-    for (int i = 0; i < s.length(); i++) {
-      lastIndex.put(s.charAt(i), i);
+    public List<Integer> partitionLabels(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < s.length(); i++) {
+            map.put(s.charAt(i), i);
+        }
+        List<Integer> result = new ArrayList<>();
+        int start = 0;
+        int maxIdx = Integer.MIN_VALUE;
+        for (int i = 0; i < s.length(); i++) {
+            maxIdx = Math.max(map.get(s.charAt(i)), maxIdx);
+            if (maxIdx == i) {
+                result.add(i - start + 1);
+                start = i + 1;
+            }
+        }
+        return result;
     }
-    List<Integer> partitionIndices = new ArrayList<>();
-    int currMaxIdx = -1;
-    int prevIdx = 0;
-    for (int i = 0; i < s.length(); i++) {
-      currMaxIdx = Math.max(currMaxIdx, lastIndex.get(s.charAt(i)));
-      if (i == currMaxIdx) {
-        partitionIndices.add(i - prevIdx + 1);
-        prevIdx = i + 1;
-      }
-    }
-    return partitionIndices;
-  }
 }

From 7977ed03d5c487dcefca359d38f582880815addd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Feb 2023 17:05:00 -0800
Subject: [PATCH 1533/2175] Update As Far from Land as Possible.java

---
 Medium/As Far from Land as Possible.java | 65 ++++++++++++------------
 1 file changed, 33 insertions(+), 32 deletions(-)

diff --git a/Medium/As Far from Land as Possible.java b/Medium/As Far from Land as Possible.java
index 2e80a70b..6e1ba29a 100644
--- a/Medium/As Far from Land as Possible.java	
+++ b/Medium/As Far from Land as Possible.java	
@@ -1,37 +1,38 @@
 class Solution {
-  private final int[][] DIRS = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
-  
-  public int maxDistance(int[][] grid) {
-    Queue<int[]> queue = new LinkedList<>();
-    int numRows = grid.length;
-    int numCols = grid[0].length;
-    for (int i = 0; i < numRows; i++) {
-      for (int j = 0; j < numCols; j++) {
-        if (grid[i][j] == 1) {
-          queue.add(new int[]{i, j});
+    
+    private static final int[][] DIRS = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
+    
+    public int maxDistance(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        Queue<int[]> queue = new LinkedList<>();    
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] == 1) {
+                    queue.add(new int[]{i, j});
+                }
+            }
         }
-      }
-    }
-    if (queue.isEmpty() || queue.size() == numRows * numCols) {
-      return -1;
-    }
-    int distance = 0;
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        for (int[] dir : DIRS) {
-          int x = removed[0] + dir[0];
-          int y = removed[1] + dir[1];
-          if (x < 0 || y < 0 || x >= numRows || y >= numCols || grid[x][y] == 1) {
-            continue;
-          }
-          grid[x][y] = 1;
-          queue.add(new int[]{x, y});
+        if (queue.isEmpty() || queue.size() == rows * cols) {
+            return -1;
+        }
+        int distance = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                for (int[] dir : DIRS) {
+                    int x = removed[0] + dir[0];
+                    int y = removed[1] + dir[1];
+                    if (x < 0 || y < 0 || x >= rows || y >= cols || grid[x][y] == 1) {
+                        continue;
+                    }
+                    grid[x][y] = 1;
+                    queue.add(new int[]{x, y});
+                }
+            }
+            distance++;
         }
-      }
-      distance++;
+        return distance - 1;
     }
-    return distance - 1; 
-  }
 }

From 7290c9653ccdcc649a0b7ff58af31b658651a31e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 11 Feb 2023 12:07:02 -0800
Subject: [PATCH 1534/2175] Update Shortest Path with Alternating Colors.java

---
 ...Shortest Path with Alternating Colors.java | 117 ++++++++----------
 1 file changed, 51 insertions(+), 66 deletions(-)

diff --git a/Medium/Shortest Path with Alternating Colors.java b/Medium/Shortest Path with Alternating Colors.java
index c2c3622a..63f670d0 100644
--- a/Medium/Shortest Path with Alternating Colors.java	
+++ b/Medium/Shortest Path with Alternating Colors.java	
@@ -1,72 +1,57 @@
 class Solution {
-  private final Integer RED = 1;
-  private final Integer BLUE = 2;
-  public int[] shortestAlternatingPaths(int n, int[][] red_edges, int[][] blue_edges) {
-    Map<Integer, List<Connection>> map = new HashMap<>();
-    for (int[] edge : red_edges) {
-      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], RED));
-    }
-    for (int[] edge : blue_edges) {
-      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], BLUE));
-    }
-    int[] distances = new int[n];
-    for (int i = 1; i < n; i++) {
-      distances[i] = getDistance(map, i, n);
-    }
-    return distances;
-  }
-  
-  private int getDistance(Map<Integer, List<Connection>> map, int target, int n) {
-    int curr = 0;
-    int steps = 0;
-    boolean found = false;
-    Queue<int[]> queue = new LinkedList<>();
-    boolean[][] visited = new boolean[2][n];
-    queue.add(new int[]{0, -1});
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        if (removed[0] == target) {
-          found = true;
-          break;
+    
+    private static final Integer RED = 1;
+    private static final Integer BLUE = 2;
+    
+    public int[] shortestAlternatingPaths(int n, int[][] red_edges, int[][] blue_edges) {
+        Map<Integer, List<Connection>> map = new HashMap<>();
+        for (int[] edge : red_edges) {
+            map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], RED));
         }
-        int color = removed[1];
-        for (Connection connection : map.getOrDefault(removed[0], new ArrayList<>())) {
-          if (color == -1 && !visited[connection.color - 1][connection.val]) {
-            visited[connection.color - 1][connection.val] = true;
-            queue.add(connection.getArray());
-          }
-          else if (color == 1 && connection.color != 1 && !visited[connection.color - 1][connection.val]) {
-            visited[connection.color - 1][connection.val] = true;
-            queue.add(connection.getArray());
-          }
-          else if (color == 2 && connection.color != 2 && !visited[connection.color - 1][connection.val]) {
-            visited[connection.color - 1][connection.val] = true;
-            queue.add(connection.getArray());
-          }
+        for (int[] edge : blue_edges) {
+            map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], BLUE));
+        }
+        int[] distances = new int[n];
+        for (int i = 1; i < n; i++) {
+            distances[i] = getDistance(map, i, n);
         }
-      }
-      if (found) {
-        break;
-      }
-      steps++;
+        return distances;
     }
-    return found ? steps : -1;
-  }
-}
-
 
-class Connection {
-  int val;
-  int color;
-  
-  public Connection(int val, int color) {
-    this.val = val;
-    this.color = color;
-  }
-  
-  public int[] getArray() {
-    return new int[]{this.val, this.color};
-  }
+    private int getDistance(Map<Integer, List<Connection>> map, int target, int n) {
+        int steps = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        boolean[][] visited = new boolean[2][n];
+        queue.add(new int[]{0, -1});
+        while (!queue.isEmpty()) {
+          int size = queue.size();
+          while (size-- > 0) {
+            int[] removed = queue.remove();
+            if (removed[0] == target) {
+              return steps;
+            }
+            int color = removed[1];
+            for (Connection connection : map.getOrDefault(removed[0], new ArrayList<>())) {
+              if (color == -1 && !visited[connection.color - 1][connection.val]) {
+                visited[connection.color - 1][connection.val] = true;
+                queue.add(connection.getArray());
+              } else if (color == 1 && connection.color != 1 && !visited[connection.color - 1][connection.val]) {
+                visited[connection.color - 1][connection.val] = true;
+                queue.add(connection.getArray());
+              } else if (color == 2 && connection.color != 2 && !visited[connection.color - 1][connection.val]) {
+                visited[connection.color - 1][connection.val] = true;
+                queue.add(connection.getArray());
+              }
+            }
+          }
+          steps++;
+        }
+        return -1;
+    }
+    
+    private record Connection(int val, int color) {
+        public int[] getArray() {
+            return new int[]{this.val, this.color};
+        }
+    }
 }

From 22b6c990c61bf5654876f76a64087fc6315d8c7a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Feb 2023 08:36:44 -0800
Subject: [PATCH 1535/2175] Create Minimum Fuel Cost to Report to the
 Capital.java

---
 ...um Fuel Cost to Report to the Capital.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Minimum Fuel Cost to Report to the Capital.java

diff --git a/Medium/Minimum Fuel Cost to Report to the Capital.java b/Medium/Minimum Fuel Cost to Report to the Capital.java
new file mode 100644
index 00000000..ee48239f
--- /dev/null
+++ b/Medium/Minimum Fuel Cost to Report to the Capital.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public long minimumFuelCost(int[][] roads, int seats) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int[] road : roads) {
+            graph.computeIfAbsent(road[0], k -> new ArrayList<>()).add(road[1]);
+            graph.computeIfAbsent(road[1], k -> new ArrayList<>()).add(road[0]);
+        }
+        long[] fuel = {0l};
+        dfs(0, -1, graph, seats, fuel);
+        return fuel[0];
+    }
+    
+    private long dfs(int node, int parent, Map<Integer, List<Integer>> graph, int seats, long[] fuel) {
+        int representativeCount = 1;
+        if (!graph.containsKey(node)) {
+            return representativeCount;
+        }
+        for (int child : graph.get(node)) {
+            if (child != parent) {
+                representativeCount += dfs(child, node, graph, seats, fuel);
+            }
+        }
+        if (node != 0) {
+            fuel[0] += Math.ceil((double) representativeCount / seats); 
+        }
+        return representativeCount;
+    }
+}

From c809100454403a9bfcf897cedfc3028e3e4c554b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Feb 2023 10:04:53 -0800
Subject: [PATCH 1536/2175] Create Find the Array Concatenation Value.java

---
 Easy/Find the Array Concatenation Value.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Find the Array Concatenation Value.java

diff --git a/Easy/Find the Array Concatenation Value.java b/Easy/Find the Array Concatenation Value.java
new file mode 100644
index 00000000..974ca82b
--- /dev/null
+++ b/Easy/Find the Array Concatenation Value.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public long findTheArrayConcVal(int[] nums) {
+        long concatenatedValue = 0;
+        int start = 0;
+        int end = nums.length - 1;
+        while (start <= end) {
+            concatenatedValue += start == end ? nums[start] : Integer.parseInt(nums[start] + "" + nums[end]);
+            start++;
+            end--;
+        }
+        return concatenatedValue;
+    }
+}

From b3d2e3be3d2d459e3a1f852c2d55bc074d4facf8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 12 Feb 2023 17:05:45 -0800
Subject: [PATCH 1537/2175] Updated Readme stats

---
 Concurrency/README.md |   11 +
 Easy/README.md        | 1010 +++++++++++++++++---------------
 Hard/README.md        |  162 +++---
 Medium/README.md      | 1282 ++++++++++++++++++++++++-----------------
 README.md             |    7 +-
 5 files changed, 1407 insertions(+), 1065 deletions(-)
 create mode 100644 Concurrency/README.md

diff --git a/Concurrency/README.md b/Concurrency/README.md
new file mode 100644
index 00000000..8bc6ef63
--- /dev/null
+++ b/Concurrency/README.md
@@ -0,0 +1,11 @@
+# Concurrency LeetCode Java Solutions 
+S.no | Coding Problem 
+--- | --- 
+1 | [Building H2O](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Building%20H2O.java)
+2 | [Design Bounded Blocking Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Design%20Bounded%20Blocking%20Queue.java)
+3 | [Fizz Buzz Multithreaded](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Fizz%20Buzz%20Multithreaded.java)
+4 | [Print FooBar Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20FooBar%20Alternately.java)
+5 | [Print Zero Even Odd](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20Zero%20Even%20Odd.java)
+6 | [Print in Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20in%20Order.java)
+7 | [The Dining Philosophers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/The%20Dining%20Philosophers.java)
+8 | [Traffic Light Controlled Intersection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Traffic%20Light%20Controlled%20Intersection.java)
diff --git a/Easy/README.md b/Easy/README.md
index 423b1cfa..63afc542 100644
--- a/Easy/README.md
+++ b/Easy/README.md
@@ -1,454 +1,560 @@
-# Easy LeetCode-Java-Solutions 
+# Easy LeetCode Java Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
-2|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
-3|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
-4|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
-5|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Stack.java)
-6|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
-7|[Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
-8|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
-9|[Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
-10|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
-11|[Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
-12|[Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
-13|[The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
-14|[Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
-15|[Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
-16|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
-17|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
-18|[Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
-19|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
-20|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bold%20Words%20in%20String.java)
-21|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
-22|[Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
-23|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
-24|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
-25|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
-26|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
-27|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
-28|[Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
-29|[Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
-30|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
-31|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
-32|[X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
-33|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Integer.java)
-34|[Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
-35|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
-36|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
-37|[Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
-38|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
-39|[Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
-40|[Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
-41|[Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
-42|[Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
-43|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
-44|[Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
-45|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Non-decreasing%20Array.java)
-46|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
-47|[Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
-48|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
-49|[Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
-50|[Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
-51|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
-52|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
-53|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
-54|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
-55|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20four.java)
-56|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
-57|[Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
-58|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
-59|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
-60|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
-61|[Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
-62|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
-63|[Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
-64|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
-65|[Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
-66|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
-67|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
-68|[Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
-69|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
-70|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
-71|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
-72|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
-73|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
-74|[Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
-75|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
-76|[Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
-77|[Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
-78|[Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
-79|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
-80|[Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
-81|[Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
-82|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
-83|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
-84|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
-85|[Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
-86|[Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
-87|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
-88|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
-89|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
-90|[Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
-91|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
-92|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
-93|[Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
-94|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
-95|[Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
-96|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
-97|[Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
-98|[Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
-99|[Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
-100|[Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
-101|[Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
-102|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20and%20Say.java)
-103|[Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
-104|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
-105|[Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
-106|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
-107|[Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
-108|[Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
-109|[DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
-110|[Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
-111|[Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
-112|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
-113|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
-114|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
-115|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
-116|[Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
-117|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20three%20numbers.java)
-118|[Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
-119|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
-120|[Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
-121|[Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
-122|[Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
-123|[Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
-124|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
-125|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
-126|[Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
-127|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
-128|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
-129|[Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
-130|[Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
-131|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
-132|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
-133|[Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
-134|[Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
-135|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
-136|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
-137|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
-138|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
-139|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
-140|[Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
-141|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
-142|[Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
-143|[Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reorder%20Data%20in%20Log%20Files.java)
-144|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
-145|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
-146|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
-147|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
-148|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
-149|[Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
-150|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Area%20of%20Island.java)
-151|[Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
-152|[Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
-153|[String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
-154|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
-155|[Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
-156|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
-157|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
-158|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
-159|[Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
-160|[Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
-161|[Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
-162|[Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
-163|[Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
-164|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
-165|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
-166|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotated%20Digits.java)
-167|[Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
-168|[Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
-169|[Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
-170|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
-171|[Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
-172|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/House%20Robber.java)
-173|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
-174|[Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
-175|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
-176|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
-177|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
-178|[Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
-179|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
-180|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
-181|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
-182|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
-183|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
-184|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
-185|[Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
-186|[Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
-187|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20II.java)
-188|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
-189|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
-190|[Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
-191|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20left%20leaves.java)
-192|[Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
-193|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
-194|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
-195|[Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java)
-196|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
-197|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
-198|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Closest%20Points%20to%20Origin.java)
-199|[Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Time%20for%20Given%20Digits.java)
-200|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
-201|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
-202|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
-203|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
-204|[Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
-205|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
-206|[Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
-207|[Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
-208|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
-209|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
-210|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
-211|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
-212|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbrevation.java)
-213|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
-214|[Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
-215|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
-216|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Anagrams%20in%20a%20String.java)
-217|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
-218|[Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
-219|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
-220|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
-221|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
-222|[How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
-223|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
-224|[Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
-225|[Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
-226|[Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
-227|[Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
-228|[Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
-229|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Stack.java)
-230|[Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
-231|[Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
-232|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
-233|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
-234|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
-235|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
-236|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
-237|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
-238|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
-239|[Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
-240|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
-241|[Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
-242|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
-243|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
-244|[Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
-245|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Level%20Order%20Traversal.java)
-246|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
-247|[First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
-248|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
-249|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
-250|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
-251|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
-252|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subdomain%20Visit%20Count.java)
-253|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
-254|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
-255|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
-256|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
-257|[Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
-258|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
-259|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
-260|[Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
-261|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
-262|[Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
-263|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
-264|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
-265|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Even%20Numbers%20After%20Queries.java)
-266|[Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
-267|[Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
-268|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20arrays%20II.java)
-269|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
-270|[Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
-271|[Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
-272|[Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
-273|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
-274|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
-275|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
-276|[Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
-277|[Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
-278|[Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
-279|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
-280|[Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
-281|[Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
-282|[Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
-283|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
-284|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
-285|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
-286|[Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
-287|[Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
-288|[Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
-289|[Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
-290|[Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
-291|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
-292|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
-293|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
-294|[Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
-295|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java)
-296|[Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
-297|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
-298|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
-299|[Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
-300|[Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
-301|[Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
-302|[Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
-303|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
-304|[Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
-305|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
-306|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java)
-307|[Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
-308|[Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
-309|[Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java)
-310|[Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
-311|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20time%20to%20buy%20&%20sell%20a%20stock%20II.java)
-312|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
-313|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
-314|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
-315|[Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
-316|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
-317|[Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
-318|[Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
-319|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
-320|[Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
-321|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
-322|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
-323|[Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
-324|[Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
-325|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
-326|[Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
-327|[Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java)
-328|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Compression.java)
-329|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
-330|[Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
-331|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
-332|[Leaf Similar Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf%20Similar%20Tree.java)
-333|[Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
-334|[Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
-335|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
-336|[Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
-337|[Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
-338|[Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
-339|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
-340|[Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
-341|[Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
-342|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
-343|[Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
-344|[Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
-345|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
-346|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
-347|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20node%20in%20a%20linked%20list.java)
-348|[Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
-349|[Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
-350|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
-351|[Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
-352|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
-353|[Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
-354|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
-355|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
-356|[Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
-357|[Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
-358|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
-359|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
-360|[Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
-361|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
-362|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
-363|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
-364|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
-365|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
-366|[Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
-367|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
-368|[Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
-369|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
-370|[Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
-371|[Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
-372|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
-373|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
-374|[Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
-375|[Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
-376|[Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
-377|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
-378|[Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java)
-379|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
-380|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20City%20Scheduling.java)
-381|[Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
-382|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/contains_duplicates.java)
-383|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
-384|[Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
-385|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
-386|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
-387|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
-388|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum%20III.java)
-389|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
-390|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
-391|[Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
-392|[Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java)
-393|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
-394|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
-395|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
-396|[Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
-397|[Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
-398|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
-399|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
-400|[Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
-401|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
-402|[Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
-403|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
-404|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
-405|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
-406|[Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
-407|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
-408|[Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
-409|[Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
-410|[Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
-411|[Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
-412|[Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
-413|[Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
-414|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
-415|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Numbers.java)
-416|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
-417|[Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
-418|[Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
-419|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
-420|[Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
-421|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
-422|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
-423|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
-424|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
-425|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
-426|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
-427|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
-428|[Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
-429|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
-430|[Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
-431|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Unsorted%20Continuous%20Subarray.java)
-432|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
-433|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
-434|[Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java)
-435|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
-436|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
-437|[Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
-438|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
-439|[Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
-440|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/sum_of_two_integers.java)
-441|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
-442|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
-443|[Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
-444|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
-445|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
-446|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
-447|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
-448|[Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
-449|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
-450|[Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java)
-451|[Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
+1 | [1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
+2 | [A Number After a Double Reversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/A%20Number%20After%20a%20Double%20Reversal.java)
+3 | [Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
+4 | [Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java)
+5 | [Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
+6 | [Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
+7 | [Alternating Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Alternating%20Digit%20Sum.java)
+8 | [Apply Operations to an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Apply%20Operations%20to%20an%20Array.java)
+9 | [Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
+10 | [Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
+11 | [Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
+12 | [Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java)
+13 | [Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
+14 | [Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
+15 | [Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java)
+16 | [Average Value of Even Numbers That Are Divisible by Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Value%20of%20Even%20Numbers%20That%20Are%20Divisible%20by%20Three.java)
+17 | [Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java)
+18 | [Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
+19 | [Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
+20 | [Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
+21 | [Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
+22 | [Best Poker Hand](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Poker%20Hand.java)
+23 | [Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java)
+24 | [Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
+25 | [Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
+26 | [Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
+27 | [Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
+28 | [Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Inorder%20Traversal.java)
+29 | [Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
+30 | [Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
+31 | [Binary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Postorder%20Traversal.java)
+32 | [Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
+33 | [Binary Watch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Watch.java)
+34 | [Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
+35 | [Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java)
+36 | [Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java)
+37 | [Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java)
+38 | [Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java)
+39 | [Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java)
+40 | [Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
+41 | [Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
+42 | [Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
+43 | [Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java)
+44 | [Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java)
+45 | [Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java)
+46 | [Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
+47 | [Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
+48 | [Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java)
+49 | [Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
+50 | [Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
+51 | [Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
+52 | [Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
+53 | [Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
+54 | [Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
+55 | [Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java)
+56 | [Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java)
+57 | [Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
+58 | [Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
+59 | [Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
+60 | [Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
+61 | [Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java)
+62 | [Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java)
+63 | [Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java)
+64 | [Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java)
+65 | [Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
+66 | [Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java)
+67 | [Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
+68 | [Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java)
+69 | [Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
+70 | [Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java)
+71 | [Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
+72 | [Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
+73 | [Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
+74 | [Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
+75 | [Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
+76 | [Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
+77 | [Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
+78 | [Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
+79 | [Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
+80 | [Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
+81 | [Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java)
+82 | [Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java)
+83 | [Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
+84 | [Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
+85 | [Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
+86 | [Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
+87 | [Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java)
+88 | [Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java)
+89 | [Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
+90 | [Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java)
+91 | [Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java)
+92 | [Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java)
+93 | [Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java)
+94 | [Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
+95 | [Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java)
+96 | [Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java)
+97 | [Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
+98 | [Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
+99 | [Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
+100 | [Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java)
+101 | [Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
+102 | [Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java)
+103 | [Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java)
+104 | [Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java)
+105 | [Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
+106 | [Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java)
+107 | [Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
+108 | [Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
+109 | [Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java)
+110 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
+111 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java)
+112 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
+113 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java)
+114 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
+115 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java)
+116 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
+117 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
+118 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
+119 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
+120 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
+121 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
+122 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
+123 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java)
+124 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
+125 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
+126 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
+127 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
+128 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
+129 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
+130 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
+131 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
+132 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java)
+133 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
+134 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
+135 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
+136 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
+137 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
+138 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java)
+139 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
+140 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
+141 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
+142 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
+143 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
+144 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
+145 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
+146 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java)
+147 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
+148 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
+149 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java)
+150 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
+151 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
+152 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
+153 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java)
+154 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java)
+155 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
+156 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
+157 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
+158 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
+159 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java)
+160 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
+161 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
+162 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
+163 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
+164 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java)
+165 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
+166 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java)
+167 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java)
+168 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
+169 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
+170 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
+171 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java)
+172 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
+173 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java)
+174 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
+175 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
+176 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
+177 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
+178 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
+179 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
+180 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
+181 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
+182 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java)
+183 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
+184 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java)
+185 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java)
+186 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
+187 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
+188 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java)
+189 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java)
+190 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java)
+191 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
+192 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
+193 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java)
+194 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java)
+195 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
+196 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
+197 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java)
+198 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
+199 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java)
+200 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
+201 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
+202 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
+203 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
+204 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
+205 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
+206 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
+207 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
+208 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
+209 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
+210 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
+211 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
+212 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java)
+213 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
+214 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
+215 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
+216 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
+217 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
+218 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
+219 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
+220 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
+221 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
+222 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
+223 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
+224 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
+225 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
+226 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
+227 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
+228 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
+229 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
+230 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java)
+231 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
+232 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java)
+233 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
+234 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
+235 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
+236 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
+237 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
+238 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
+239 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
+240 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
+241 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
+242 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java)
+243 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
+244 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
+245 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java)
+246 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
+247 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
+248 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java)
+249 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java)
+250 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java)
+251 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
+252 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
+253 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
+254 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java)
+255 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
+256 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
+257 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
+258 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
+259 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
+260 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
+261 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
+262 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
+263 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
+264 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
+265 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
+266 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
+267 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
+268 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
+269 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
+270 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
+271 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
+272 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
+273 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
+274 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java)
+275 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
+276 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
+277 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
+278 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
+279 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
+280 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
+281 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
+282 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java)
+283 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
+284 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
+285 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
+286 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
+287 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java)
+288 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
+289 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
+290 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
+291 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java)
+292 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
+293 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java)
+294 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
+295 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java)
+296 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
+297 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
+298 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
+299 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java)
+300 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java)
+301 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
+302 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
+303 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
+304 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java)
+305 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
+306 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
+307 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
+308 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java)
+309 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
+310 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java)
+311 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
+312 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
+313 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
+314 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java)
+315 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
+316 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
+317 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
+318 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
+319 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
+320 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
+321 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java)
+322 | [Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
+323 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
+324 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java)
+325 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java)
+326 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
+327 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java)
+328 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java)
+329 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java)
+330 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java)
+331 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
+332 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
+333 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
+334 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
+335 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java)
+336 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
+337 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java)
+338 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
+339 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java)
+340 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java)
+341 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
+342 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java)
+343 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
+344 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java)
+345 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
+346 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
+347 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
+348 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
+349 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
+350 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
+351 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java)
+352 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
+353 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
+354 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java)
+355 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java)
+356 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
+357 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
+358 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
+359 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
+360 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
+361 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
+362 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
+363 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
+364 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
+365 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
+366 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
+367 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
+368 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
+369 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
+370 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java)
+371 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
+372 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java)
+373 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
+374 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
+375 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
+376 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java)
+377 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
+378 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
+379 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
+380 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
+381 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
+382 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
+383 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
+384 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
+385 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java)
+386 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java)
+387 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
+388 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
+389 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java)
+390 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
+391 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
+392 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
+393 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
+394 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
+395 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
+396 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
+397 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
+398 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
+399 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
+400 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
+401 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
+402 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
+403 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java)
+404 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
+405 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
+406 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
+407 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
+408 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java)
+409 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
+410 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
+411 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
+412 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
+413 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
+414 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java)
+415 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
+416 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
+417 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
+418 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java)
+419 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
+420 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java)
+421 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
+422 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
+423 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
+424 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
+425 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
+426 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
+427 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
+428 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java)
+429 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
+430 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
+431 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
+432 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java)
+433 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
+434 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
+435 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
+436 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java)
+437 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
+438 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
+439 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
+440 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
+441 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
+442 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
+443 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
+444 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
+445 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
+446 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
+447 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java)
+448 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
+449 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
+450 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
+451 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
+452 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
+453 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java)
+454 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
+455 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
+456 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java)
+457 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
+458 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
+459 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
+460 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
+461 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
+462 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
+463 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
+464 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
+465 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
+466 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java)
+467 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
+468 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
+469 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java)
+470 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
+471 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
+472 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
+473 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
+474 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
+475 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java)
+476 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
+477 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
+478 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
+479 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java)
+480 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java)
+481 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
+482 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
+483 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
+484 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
+485 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java)
+486 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
+487 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java)
+488 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
+489 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
+490 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
+491 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
+492 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
+493 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
+494 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
+495 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
+496 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
+497 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java)
+498 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
+499 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
+500 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
+501 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
+502 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
+503 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java)
+504 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
+505 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
+506 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
+507 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
+508 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java)
+509 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
+510 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
+511 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
+512 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
+513 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
+514 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java)
+515 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java)
+516 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
+517 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java)
+518 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
+519 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
+520 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
+521 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
+522 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
+523 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java)
+524 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
+525 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
+526 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
+527 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
+528 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java)
+529 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java)
+530 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
+531 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
+532 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
+533 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
+534 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
+535 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
+536 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
+537 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
+538 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
+539 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
+540 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
+541 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
+542 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
+543 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
+544 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
+545 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
+546 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
+547 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java)
+548 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
+549 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java)
+550 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
+551 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
+552 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
+553 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
+554 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java)
+555 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
+556 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
+557 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
diff --git a/Hard/README.md b/Hard/README.md
index 06ab9137..75b409d1 100644
--- a/Hard/README.md
+++ b/Hard/README.md
@@ -1,69 +1,97 @@
-# Hard LeetCode-Java-Solutions 
+# Hard LeetCode Java Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
-2|[Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
-3|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
-4|[Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
-5|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
-6|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
-7|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
-8|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
-9|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
-10|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
-11|[Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Interval.java)
-12|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
-13|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
-14|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
-15|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
-16|[Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
-17|[Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
-18|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parallel%20Courses.java)
-19|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
-20|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
-21|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
-22|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
-23|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
-24|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
-25|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
-26|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
-27|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
-28|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
-29|[Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
-30|[Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
-31|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
-32|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
-33|[Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
-34|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
-35|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LRU%20Cache.java)
-36|[Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
-37|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
-38|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
-39|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md)
-40|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
-41|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
-42|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
-43|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20From%20Data%20Stream.java)
-44|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
-45|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
-46|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
-47|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
-48|[Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
-49|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
-50|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
-51|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Interleaving%20String.java)
-52|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
-53|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
-54|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
-55|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
-56|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
-57|[Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
-58|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
-59|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
-60|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
-61|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20PostOrder%20Traversal.java)
-62|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
-63|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
-64|[Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
-65|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
-66|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
+1 | [Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java)
+2 | [Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
+3 | [Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
+4 | [Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java)
+5 | [Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java)
+6 | [Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
+7 | [Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
+8 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
+9 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
+10 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java)
+11 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java)
+12 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java)
+13 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java)
+14 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java)
+15 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
+16 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java)
+17 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java)
+18 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
+19 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java)
+20 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java)
+21 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
+22 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
+23 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
+24 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java)
+25 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java)
+26 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
+27 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java)
+28 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
+29 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
+30 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
+31 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
+32 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
+33 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java)
+34 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java)
+35 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
+36 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
+37 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
+38 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
+39 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java)
+40 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java)
+41 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java)
+42 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
+43 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
+44 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java)
+45 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java)
+46 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
+47 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
+48 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
+49 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
+50 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
+51 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java)
+52 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java)
+53 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java)
+54 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
+55 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java)
+56 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java)
+57 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
+58 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java)
+59 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
+60 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
+61 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
+62 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
+63 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
+64 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
+65 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java)
+66 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
+67 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
+68 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java)
+69 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java)
+70 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
+71 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java)
+72 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
+73 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
+74 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
+75 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
+76 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
+77 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
+78 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
+79 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
+80 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
+81 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java)
+82 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
+83 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java)
+84 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
+85 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
+86 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
+87 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java)
+88 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
+89 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
+90 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
+91 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java)
+92 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java)
+93 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
+94 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
diff --git a/Medium/README.md b/Medium/README.md
index 549b4e57..afdf245d 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -1,545 +1,741 @@
-# Medium LeetCode-Java-Solutions 
+# Medium LeetCode Java Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
-2|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Ranges.java)
-3|[First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
-4|[Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
-5|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
-6|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
-7|[Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
-8|[House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
-9|[Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
-10|[Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
-11|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
-12|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
-13|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Itinerary.java)
-14|[Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
-15|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
-16|[Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
-17|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
-18|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
-19|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
-20|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
-21|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
-22|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
-23|[Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
-24|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
-25|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
-26|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
-27|[Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
-28|[Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
-29|[Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
-30|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Overlap.java)
-31|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
-32|[Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
-33|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
-34|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
-35|[Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
-36|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
-37|[Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
-38|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
-39|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
-40|[Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
-41|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
-42|[Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
-43|[Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
-44|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
-45|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
-46|[Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
-47|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
-48|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
-49|[Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
-50|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
-51|[Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
-52|[Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
-53|[Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
-54|[Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
-55|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
-56|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
-57|[Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
-58|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
-59|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
-60|[Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
-61|[Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
-62|[Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
-63|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
-64|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
-65|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
-66|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
-67|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
-68|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
-69|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
-70|[Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
-71|[Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
-72|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
-73|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
-74|[Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
-75|[Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
-76|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
-77|[Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
-78|[Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
-79|[Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
-80|[Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
-81|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
-82|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
-83|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
-84|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
-85|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
-86|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
-87|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
-88|[Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
-89|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Town%20Judge.java)
-90|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
-91|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
-92|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
-93|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
-94|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
-95|[Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
-96|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
-97|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
-98|[Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
-99|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
-100|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
-101|[Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
-102|[Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
-103|[Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
-104|[Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
-105|[Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
-106|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
-107|[Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
-108|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
-109|[Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
-110|[Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
-111|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
-112|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
-113|[Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
-114|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
-115|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
-116|[Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
-117|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
-118|[Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
-119|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
-120|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
-121|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
-122|[Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
-123|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
-124|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
-125|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
-126|[Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
-127|[Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
-128|[Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
-129|[House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
-130|[Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
-131|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
-132|[Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
-133|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
-134|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
-135|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
-136|[Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
-137|[Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
-138|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
-139|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
-140|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
-141|[Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
-142|[Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
-143|[Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
-144|[Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
-145|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
-146|[Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
-147|[Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
-148|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
-149|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20into%20Parts.java)
-150|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
-151|[Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
-152|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
-153|[Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
-154|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
-155|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
-156|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
-157|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
-158|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
-159|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
-160|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
-161|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
-162|[Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
-163|[Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
-164|[Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
-165|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
-166|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
-167|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
-168|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
-169|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
-170|[Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
-171|[Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
-172|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
-173|[Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
-174|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
-175|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
-176|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
-177|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
-178|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
-179|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
-180|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
-181|[Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
-182|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
-183|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
-184|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
-185|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
-186|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
-187|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
-188|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
-189|[Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
-190|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
-191|[Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
-192|[Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
-193|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
-194|[Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
-195|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
-196|[Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
-197|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
-198|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
-199|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
-200|[Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
-201|[Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
-202|[Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
-203|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
-204|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Inorder%20Traversal.java)
-205|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
-206|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
-207|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
-208|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
-209|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
-210|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
-211|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
-212|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
-213|[Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
-214|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
-215|[Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
-216|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
-217|[Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
-218|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
-219|[Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
-220|[Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
-221|[Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
-222|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Subsequence.java)
-223|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
-224|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
-225|[Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
-226|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
-227|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
-228|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
-229|[Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
-230|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
-231|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
-232|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
-233|[Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
-234|[Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
-235|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
-236|[Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
-237|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
-238|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
-239|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
-240|[Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
-241|[Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
-242|[All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
-243|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
-244|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
-245|[Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
-246|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
-247|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
-248|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
-249|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
-250|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
-251|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
-252|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
-253|[Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
-254|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
-255|[Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
-256|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
-257|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
-258|[Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
-259|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
-260|[HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
-261|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
-262|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
-263|[Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
-264|[Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
-265|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
-266|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
-267|[Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
-268|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
-269|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
-270|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
-271|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
-272|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
-273|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
-274|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
-275|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
-276|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
-277|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
-278|[Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
-279|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
-280|[Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
-281|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
-282|[The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
-283|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
-284|[Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
-285|[Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
-286|[Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
-287|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
-288|[Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
-289|[Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
-290|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
-291|[Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
-292|[Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
-293|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
-294|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vertical%20Order%20Traversal%20Of%20Binary%20Tree.java)
-295|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
-296|[Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
-297|[Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
-298|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
-299|[Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
-300|[Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
-301|[Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
-302|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
-303|[Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
-304|[Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
-305|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
-306|[4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
-307|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
-308|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
-309|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
-310|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
-311|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
-312|[Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
-313|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
-314|[Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
-315|[Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
-316|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
-317|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
-318|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
-319|[Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
-320|[Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
-321|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
-322|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
-323|[Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
-324|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
-325|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
-326|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
-327|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
-328|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
-329|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
-330|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
-331|[Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
-332|[Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
-333|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
-334|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
-335|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
-336|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
-337|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
-338|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
-339|[Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
-340|[Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
-341|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
-342|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
-343|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
-344|[Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
-345|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20and%20Search%20Word%20-%20Data%20structure%20design.java)
-346|[Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
-347|[Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
-348|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
-349|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
-350|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
-351|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
-352|[Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
-353|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
-354|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
-355|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
-356|[Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
-357|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
-358|[Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
-359|[Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
-360|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
-361|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
-362|[Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
-363|[Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
-364|[Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
-365|[Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
-366|[Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
-367|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
-368|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
-369|[Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
-370|[Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
-371|[Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
-372|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
-373|[Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
-374|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
-375|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
-376|[Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
-377|[Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
-378|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
-379|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
-380|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
-381|[Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
-382|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
-383|[Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
-384|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
-385|[The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
-386|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
-387|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
-388|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
-389|[Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
-390|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
-391|[Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
-392|[Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
-393|[Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
-394|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
-395|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
-396|[Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
-397|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
-398|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
-399|[Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
-400|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
-401|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
-402|[Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
-403|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
-404|[Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
-405|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
-406|[Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
-407|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
-408|[Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
-409|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
-410|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
-411|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Counting%20Bits.java)
-412|[Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
-413|[Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
-414|[Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
-415|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
-416|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
-417|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
-418|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
-419|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
-420|[Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
-421|[132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java)
-422|[Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
-423|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
-424|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20duplicate%20number.java)
-425|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
-426|[Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
-427|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
-428|[Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
-429|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
-430|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
-431|[Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
-432|[Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
-433|[Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
-434|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
-435|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
-436|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
-437|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
-438|[Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
-439|[Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
-440|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
-441|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
-442|[Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
-443|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
-444|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
-445|[Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
-446|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
-447|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
-448|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
-449|[Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
-450|[Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
-451|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
-452|[The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
-453|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
-454|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
-455|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Teemo%20Attacking.java)
-456|[Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
-457|[Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
-458|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
-459|[Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
-460|[Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
-461|[Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
-462|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
-463|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
-464|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
-465|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
-466|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
-467|[Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
-468|[Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
-469|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
-470|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
-471|[Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
-472|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
-473|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
-474|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
-475|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
-476|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
-477|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer(atoi).java)
-478|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
-479|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
-480|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
-481|[Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
-482|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
-483|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
-484|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
-485|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
-486|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
-487|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
-488|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
-489|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
-490|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
-491|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
-492|[Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
-493|[Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
-494|[Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
-495|[Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
-496|[Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
-497|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
-498|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
-499|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
-500|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
-501|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
-502|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
-503|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
-504|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
-505|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
-506|[Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
-507|[People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
-508|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
-509|[All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
-510|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
-511|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
-512|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
-513|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
-514|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
-515|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
-516|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md)
-517|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
-518|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
-519|[Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
-520|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
-521|[Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
-522|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
-523|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
-524|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
-525|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
-526|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
-527|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
-528|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
-529|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
-530|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
-531|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
-532|[Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
-533|[Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
-534|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
-535|[Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
-536|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
-537|[Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
-538|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
-539|[Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
-540|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
-541|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
-542|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
+1 | [01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
+2 | [132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java)
+3 | [3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
+4 | [3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
+5 | [3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java)
+6 | [3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
+7 | [4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
+8 | [4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
+9 | [4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
+10 | [Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
+11 | [Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
+12 | [Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
+13 | [Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
+14 | [Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
+15 | [Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
+16 | [Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java)
+17 | [Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
+18 | [Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
+19 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
+20 | [All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java)
+21 | [All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java)
+22 | [All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
+23 | [All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
+24 | [All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
+25 | [All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
+26 | [All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
+27 | [Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
+28 | [Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
+29 | [Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java)
+30 | [Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java)
+31 | [Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
+32 | [Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java)
+33 | [Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
+34 | [Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
+35 | [Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
+36 | [Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
+37 | [As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
+38 | [Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
+39 | [Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
+40 | [Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java)
+41 | [Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java)
+42 | [Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
+43 | [Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
+44 | [Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java)
+45 | [Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
+46 | [Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java)
+47 | [Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
+48 | [Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
+49 | [Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
+50 | [Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java)
+51 | [Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
+52 | [Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
+53 | [Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
+54 | [Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
+55 | [Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
+56 | [Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
+57 | [Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
+58 | [Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
+59 | [Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java)
+60 | [Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
+61 | [Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
+62 | [Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java)
+63 | [Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java)
+64 | [Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
+65 | [Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java)
+66 | [Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
+67 | [Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
+68 | [Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java)
+69 | [Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
+70 | [Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
+71 | [Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
+72 | [Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
+73 | [Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
+74 | [Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
+75 | [Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
+76 | [Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
+77 | [Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
+78 | [Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
+79 | [Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java)
+80 | [Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
+81 | [Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
+82 | [Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
+83 | [Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
+84 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
+85 | [Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
+86 | [Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
+87 | [Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
+88 | [Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
+89 | [Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
+90 | [Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java)
+91 | [Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
+92 | [Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
+93 | [Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
+94 | [Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
+95 | [Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java)
+96 | [Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
+97 | [Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
+98 | [Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
+99 | [Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
+100 | [Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
+101 | [Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java)
+102 | [Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java)
+103 | [Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
+104 | [Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
+105 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java)
+106 | [Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
+107 | [Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
+108 | [Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java)
+109 | [Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
+110 | [Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
+111 | [Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
+112 | [Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java)
+113 | [Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
+114 | [Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
+115 | [Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
+116 | [Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
+117 | [Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java)
+118 | [Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
+119 | [Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
+120 | [Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java)
+121 | [Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java)
+122 | [Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java)
+123 | [Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java)
+124 | [Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
+125 | [Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
+126 | [Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
+127 | [Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
+128 | [Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
+129 | [Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
+130 | [Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java)
+131 | [Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
+132 | [Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
+133 | [Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java)
+134 | [Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java)
+135 | [Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java)
+136 | [Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
+137 | [Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
+138 | [Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java)
+139 | [Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
+140 | [Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
+141 | [Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
+142 | [Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
+143 | [Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
+144 | [Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
+145 | [Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
+146 | [Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
+147 | [Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
+148 | [Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
+149 | [Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
+150 | [Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java)
+151 | [Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
+152 | [Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java)
+153 | [Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
+154 | [Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
+155 | [Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
+156 | [Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
+157 | [Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
+158 | [Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java)
+159 | [Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
+160 | [Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
+161 | [Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
+162 | [Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java)
+163 | [Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java)
+164 | [Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
+165 | [Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
+166 | [Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
+167 | [Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
+168 | [Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
+169 | [Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java)
+170 | [Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java)
+171 | [Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
+172 | [Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
+173 | [Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
+174 | [Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
+175 | [Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
+176 | [Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
+177 | [Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java)
+178 | [Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
+179 | [Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
+180 | [Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
+181 | [Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
+182 | [Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java)
+183 | [Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
+184 | [Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
+185 | [Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
+186 | [Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java)
+187 | [Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
+188 | [Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
+189 | [Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java)
+190 | [Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
+191 | [Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java)
+192 | [Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
+193 | [Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
+194 | [Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java)
+195 | [Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java)
+196 | [Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
+197 | [Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
+198 | [Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java)
+199 | [Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java)
+200 | [Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java)
+201 | [Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
+202 | [Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
+203 | [Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
+204 | [Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
+205 | [Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
+206 | [Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
+207 | [Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
+208 | [Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
+209 | [Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
+210 | [Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
+211 | [Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java)
+212 | [Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
+213 | [Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java)
+214 | [Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
+215 | [Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
+216 | [Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java)
+217 | [Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
+218 | [Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
+219 | [Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
+220 | [Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java)
+221 | [Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java)
+222 | [Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
+223 | [Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
+224 | [Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
+225 | [Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
+226 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
+227 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
+228 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java)
+229 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
+230 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
+231 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java)
+232 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
+233 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
+234 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
+235 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
+236 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
+237 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
+238 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
+239 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
+240 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
+241 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
+242 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
+243 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
+244 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java)
+245 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
+246 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java)
+247 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
+248 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
+249 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
+250 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
+251 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
+252 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
+253 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
+254 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
+255 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
+256 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
+257 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
+258 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
+259 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
+260 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
+261 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
+262 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
+263 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java)
+264 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java)
+265 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
+266 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
+267 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
+268 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java)
+269 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
+270 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
+271 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
+272 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
+273 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
+274 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
+275 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java)
+276 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
+277 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
+278 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
+279 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
+280 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
+281 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
+282 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java)
+283 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
+284 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
+285 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
+286 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
+287 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java)
+288 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java)
+289 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java)
+290 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
+291 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java)
+292 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java)
+293 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
+294 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
+295 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
+296 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
+297 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
+298 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
+299 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
+300 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
+301 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java)
+302 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
+303 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
+304 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
+305 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java)
+306 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
+307 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
+308 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
+309 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
+310 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java)
+311 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
+312 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
+313 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java)
+314 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java)
+315 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
+316 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
+317 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
+318 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
+319 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
+320 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
+321 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
+322 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
+323 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java)
+324 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
+325 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
+326 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java)
+327 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
+328 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
+329 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
+330 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
+331 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java)
+332 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
+333 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
+334 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+335 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java)
+336 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
+337 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java)
+338 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
+339 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
+340 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
+341 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java)
+342 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
+343 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
+344 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
+345 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
+346 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
+347 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java)
+348 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java)
+349 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
+350 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
+351 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
+352 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
+353 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java)
+354 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
+355 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java)
+356 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
+357 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java)
+358 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java)
+359 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
+360 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java)
+361 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
+362 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java)
+363 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
+364 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
+365 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java)
+366 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
+367 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
+368 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
+369 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
+370 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
+371 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java)
+372 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
+373 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
+374 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java)
+375 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java)
+376 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java)
+377 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java)
+378 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java)
+379 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java)
+380 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
+381 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
+382 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
+383 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java)
+384 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
+385 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java)
+386 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java)
+387 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
+388 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java)
+389 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
+390 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java)
+391 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java)
+392 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java)
+393 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java)
+394 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java)
+395 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java)
+396 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
+397 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
+398 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
+399 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
+400 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
+401 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
+402 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
+403 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
+404 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
+405 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java)
+406 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java)
+407 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java)
+408 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
+409 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
+410 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
+411 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java)
+412 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
+413 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java)
+414 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
+415 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java)
+416 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java)
+417 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
+418 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
+419 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java)
+420 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
+421 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
+422 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java)
+423 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java)
+424 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
+425 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java)
+426 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
+427 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
+428 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
+429 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java)
+430 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java)
+431 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
+432 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java)
+433 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
+434 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
+435 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
+436 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
+437 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
+438 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
+439 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java)
+440 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
+441 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
+442 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java)
+443 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
+444 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java)
+445 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java)
+446 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java)
+447 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java)
+448 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
+449 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
+450 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java)
+451 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java)
+452 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
+453 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
+454 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
+455 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
+456 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java)
+457 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java)
+458 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
+459 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
+460 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
+461 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
+462 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
+463 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
+464 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java)
+465 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
+466 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java)
+467 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
+468 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java)
+469 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
+470 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java)
+471 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
+472 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
+473 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
+474 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java)
+475 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java)
+476 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
+477 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java)
+478 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
+479 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
+480 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
+481 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
+482 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java)
+483 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java)
+484 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java)
+485 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java)
+486 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
+487 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
+488 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
+489 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
+490 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java)
+491 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java)
+492 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
+493 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
+494 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
+495 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java)
+496 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
+497 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
+498 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
+499 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
+500 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java)
+501 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java)
+502 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
+503 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java)
+504 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
+505 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
+506 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
+507 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java)
+508 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java)
+509 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java)
+510 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
+511 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
+512 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
+513 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
+514 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java)
+515 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
+516 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
+517 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
+518 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
+519 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
+520 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
+521 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
+522 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
+523 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
+524 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
+525 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
+526 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
+527 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
+528 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java)
+529 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
+530 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java)
+531 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
+532 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
+533 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
+534 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
+535 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
+536 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
+537 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
+538 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java)
+539 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
+540 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
+541 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java)
+542 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java)
+543 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
+544 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
+545 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
+546 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
+547 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
+548 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
+549 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
+550 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
+551 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
+552 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
+553 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
+554 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java)
+555 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java)
+556 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
+557 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java)
+558 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
+559 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
+560 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
+561 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
+562 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
+563 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java)
+564 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
+565 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
+566 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
+567 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
+568 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java)
+569 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
+570 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
+571 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
+572 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java)
+573 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
+574 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
+575 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
+576 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java)
+577 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java)
+578 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
+579 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
+580 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java)
+581 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
+582 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
+583 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java)
+584 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
+585 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
+586 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
+587 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java)
+588 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
+589 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java)
+590 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java)
+591 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
+592 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
+593 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
+594 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
+595 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
+596 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
+597 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
+598 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
+599 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java)
+600 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
+601 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java)
+602 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
+603 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
+604 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
+605 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
+606 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java)
+607 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
+608 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
+609 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
+610 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
+611 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
+612 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
+613 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
+614 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java)
+615 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
+616 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
+617 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
+618 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
+619 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
+620 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
+621 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java)
+622 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
+623 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
+624 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
+625 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java)
+626 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
+627 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
+628 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
+629 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
+630 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java)
+631 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
+632 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
+633 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
+634 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
+635 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
+636 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
+637 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
+638 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java)
+639 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
+640 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java)
+641 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
+642 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
+643 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
+644 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
+645 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
+646 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
+647 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java)
+648 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
+649 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
+650 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java)
+651 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
+652 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java)
+653 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
+654 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
+655 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
+656 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
+657 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
+658 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java)
+659 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
+660 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java)
+661 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java)
+662 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java)
+663 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java)
+664 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java)
+665 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
+666 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
+667 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
+668 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java)
+669 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
+670 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
+671 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
+672 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java)
+673 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
+674 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
+675 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java)
+676 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java)
+677 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
+678 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java)
+679 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java)
+680 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
+681 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
+682 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
+683 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
+684 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
+685 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java)
+686 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
+687 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
+688 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
+689 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
+690 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
+691 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java)
+692 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
+693 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
+694 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
+695 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
+696 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
+697 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java)
+698 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
+699 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
+700 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
+701 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java)
+702 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java)
+703 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
+704 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
+705 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java)
+706 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java)
+707 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
+708 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java)
+709 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java)
+710 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
+711 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
+712 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
+713 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
+714 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
+715 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
+716 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
+717 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
+718 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
+719 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
+720 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
+721 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
+722 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
+723 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
+724 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
+725 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
+726 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java)
+727 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
+728 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
+729 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java)
+730 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
+731 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
+732 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java)
+733 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
+734 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
+735 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
+736 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java)
+737 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
+738 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
diff --git a/README.md b/README.md
index 92c01bb6..e264f9eb 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@
 
 Problem Category | Count
 --- | --- 
-[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 452
-[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 543
-[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 67
+[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 558
+[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 739
+[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 95
+[Concurrency](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Concurrency/README.md) | 9

From 941a02b99156b765207db30669a59e0a85fe346e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Feb 2023 10:03:21 -0800
Subject: [PATCH 1538/2175] Update Print Zero Even Odd.java

---
 Concurrency/Print Zero Even Odd.java | 69 ++++++++++++++--------------
 1 file changed, 35 insertions(+), 34 deletions(-)

diff --git a/Concurrency/Print Zero Even Odd.java b/Concurrency/Print Zero Even Odd.java
index 35b3a599..784b7fd7 100644
--- a/Concurrency/Print Zero Even Odd.java	
+++ b/Concurrency/Print Zero Even Odd.java	
@@ -1,42 +1,43 @@
 class ZeroEvenOdd {
-  private int n;
-  private int flag = 0;
-
-  public ZeroEvenOdd(int n) {
-    this.n = n;
-  }
+    private int n;
+    
+    private final Semaphore zeroMutex;
+    private final Semaphore oddMutex;
+    private final Semaphore evenMutex;
+    
+    public ZeroEvenOdd(int n) {
+        this.n = n;
+        this.zeroMutex = new Semaphore(1);
+        this.oddMutex = new Semaphore(0);
+        this.evenMutex = new Semaphore(0);
+    }
 
-  // printNumber.accept(x) outputs "x", where x is an integer.
-  public synchronized void zero(IntConsumer printNumber) throws InterruptedException {
-    for (int i = 0; i < n; i++) {
-      while (flag != 0) {
-        this.wait();
-      }
-      printNumber.accept(0);
-      flag = i % 2 == 0 ? 1 : 2;
-      this.notifyAll();
+    // printNumber.accept(x) outputs "x", where x is an integer.
+    public void zero(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 0; i < n; i++) {
+            this.zeroMutex.acquire();
+            printNumber.accept(0);
+            if (i % 2 == 0) {
+                this.oddMutex.release();
+            } else {
+                this.evenMutex.release();
+            }
+        }
     }
-  }
 
-  public synchronized void even(IntConsumer printNumber) throws InterruptedException {
-    for (int i = 2; i <= n; i += 2) {
-      while (flag != 2) {
-        this.wait();
-      }
-      printNumber.accept(i);
-      flag = 0;
-      this.notifyAll();
+    public void even(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 2; i <= n; i += 2) {
+            this.evenMutex.acquire();
+            printNumber.accept(i);
+            this.zeroMutex.release();
+        }
     }
-  }
 
-  public synchronized void odd(IntConsumer printNumber) throws InterruptedException {
-    for (int i = 1; i <= n; i += 2) {
-      while (flag != 1) {
-        this.wait();
-      }
-      printNumber.accept(i);
-      flag = 0;
-      this.notifyAll();
+    public void odd(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 1; i <= n; i += 2) {
+            this.oddMutex.acquire();
+            printNumber.accept(i);
+            this.zeroMutex.release();
+        } 
     }
-  }
 }

From 87be42c91377f21ea55b34ec2417a668b5efdd2b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Feb 2023 14:19:47 -0800
Subject: [PATCH 1539/2175] Update Fizz Buzz Multithreaded.java

---
 Concurrency/Fizz Buzz Multithreaded.java | 124 +++++++++++------------
 1 file changed, 59 insertions(+), 65 deletions(-)

diff --git a/Concurrency/Fizz Buzz Multithreaded.java b/Concurrency/Fizz Buzz Multithreaded.java
index 2e213c7c..b749ba25 100644
--- a/Concurrency/Fizz Buzz Multithreaded.java	
+++ b/Concurrency/Fizz Buzz Multithreaded.java	
@@ -1,77 +1,71 @@
 class FizzBuzz {
-  private int n;
-  private int count;
-  private Semaphore fizz;
-  private Semaphore buzz;
-  private Semaphore fizzBuzz;
-  private Semaphore number;
+    private int n;
+    private final Semaphore fizzSemaphore;
+    private final Semaphore buzzSemaphore;
+    private final Semaphore fizzBuzzSemaphore;
+    private final Semaphore numSemaphore;
 
-  public FizzBuzz(int n) {
-    this.n = n;
-    this.count = 1;
-    this.fizz = new Semaphore(0);
-    this.buzz = new Semaphore(0);
-    this.fizzBuzz = new Semaphore(0);
-    this.number = new Semaphore(1);
-  }
+    public FizzBuzz(int n) {
+        this.n = n;
+        this.fizzSemaphore = new Semaphore(0);
+        this.buzzSemaphore = new Semaphore(0);
+        this.fizzBuzzSemaphore = new Semaphore(0);
+        this.numSemaphore = new Semaphore(1);
+    }
 
-  // printFizz.run() outputs "fizz".
-  public void fizz(Runnable printFizz) throws InterruptedException {
-    while (this.count <= this.n) {
-      if (this.count % 3 == 0 && this.count % 5 != 0) {
-        this.fizz.acquire();
-        printFizz.run();
-        this.count++;
-        releaseLock(this.count);
-      }
+    // printFizz.run() outputs "fizz".
+    public void fizz(Runnable printFizz) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 == 0 && i % 5 != 0) {
+                fizzSemaphore.acquire();
+                printFizz.run();
+                releaseLock(i + 1);
+            }
+        }
     }
-  }
 
-  // printBuzz.run() outputs "buzz".
-  public void buzz(Runnable printBuzz) throws InterruptedException {
-    while (this.count <= this.n) {
-      if (this.count % 3 != 0 && this.count % 5 == 0) {
-        this.buzz.acquire();
-        printBuzz.run();
-        this.count++;
-        releaseLock(this.count);
-      }
+    // printBuzz.run() outputs "buzz".
+    public void buzz(Runnable printBuzz) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 != 0 && i % 5 == 0) {
+                buzzSemaphore.acquire();
+                printBuzz.run();
+                releaseLock(i + 1);
+            }
+        }
     }
-  }
 
-  // printFizzBuzz.run() outputs "fizzbuzz".
-  public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
-    while (this.count <= this.n) {
-      if (this.count % 3 == 0 && this.count % 5 == 0) {
-        this.fizzBuzz.acquire();
-        printFizzBuzz.run();
-        this.count++;
-        releaseLock(this.count);
-      }
+    // printFizzBuzz.run() outputs "fizzbuzz".
+    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 == 0 && i % 5 == 0) {
+                fizzBuzzSemaphore.acquire();
+                printFizzBuzz.run();
+                releaseLock(i + 1);
+            }
+        }
     }
-  }
 
-  // printNumber.accept(x) outputs "x", where x is an integer.
-  public void number(IntConsumer printNumber) throws InterruptedException {
-    while (this.count <= this.n) {
-      if (this.count % 3 != 0 && this.count % 5 != 0) {
-        this.number.acquire();
-        printNumber.accept(this.count);
-        this.count++;
-        releaseLock(this.count);
-      }
+    // printNumber.accept(x) outputs "x", where x is an integer.
+    public void number(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 != 0 && i % 5 != 0) {
+                numSemaphore.acquire();
+                printNumber.accept(i);
+                releaseLock(i + 1);
+            }
+        }
     }
-  }
-  
-  private void releaseLock(int n) {
-    if (n % 15 == 0) {
-      this.fizzBuzz.release();
-    } else if (n % 3 == 0) {
-      this.fizz.release();
-    } else if (n % 5 == 0) {
-      this.buzz.release();
-    } else {
-      this.number.release();
+    
+    private void releaseLock(int num) {
+        if (num % 3 == 0 && num % 5 == 0) {
+            fizzBuzzSemaphore.release();
+        } else if (num % 3 == 0 && num % 5 != 0) {
+            fizzSemaphore.release();
+        } else if (num % 3 != 0 && num % 5 == 0) {
+            buzzSemaphore.release();
+        } else {
+            numSemaphore.release();
+        }
     }
-  }
 }

From 1f05921833771527f5641a8aeca47ecf237a7866 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 14 Feb 2023 06:34:22 -0800
Subject: [PATCH 1540/2175] Update and rename Easy/Maximum Subarray.java to
 Medium/Maximum Subarray.java

---
 Easy/Maximum Subarray.java   | 14 --------------
 Medium/Maximum Subarray.java | 14 ++++++++++++++
 2 files changed, 14 insertions(+), 14 deletions(-)
 delete mode 100644 Easy/Maximum Subarray.java
 create mode 100644 Medium/Maximum Subarray.java

diff --git a/Easy/Maximum Subarray.java b/Easy/Maximum Subarray.java
deleted file mode 100644
index 46b106c7..00000000
--- a/Easy/Maximum Subarray.java	
+++ /dev/null
@@ -1,14 +0,0 @@
-class Solution {
-  public int maxSubArray(int[] nums) {
-    int currSum = 0;
-    int maxSum = Integer.MIN_VALUE;
-    for (int num : nums) {
-      currSum += num;
-      if (num > currSum) {
-        currSum = num;
-      }
-      maxSum = Math.max(maxSum, currSum);
-    }
-    return maxSum;
-  }
-}
diff --git a/Medium/Maximum Subarray.java b/Medium/Maximum Subarray.java
new file mode 100644
index 00000000..459a8733
--- /dev/null
+++ b/Medium/Maximum Subarray.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int currSum = 0;
+        int maxSum = Integer.MIN_VALUE;
+        for (int num : nums) {
+            currSum += num;
+            if (currSum < num) {
+                currSum = num;
+            }
+            maxSum = Math.max(maxSum, currSum);
+        }
+        return maxSum;
+    }
+}

From c83324310a19917ce235b528685059aea0d12cbd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 14 Feb 2023 16:17:25 -0800
Subject: [PATCH 1541/2175] Update Add to Array-Form of Integer.java

---
 Easy/Add to Array-Form of Integer.java | 31 ++++++++++++++++----------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/Easy/Add to Array-Form of Integer.java b/Easy/Add to Array-Form of Integer.java
index 1ef362dd..64cbbb31 100644
--- a/Easy/Add to Array-Form of Integer.java	
+++ b/Easy/Add to Array-Form of Integer.java	
@@ -1,15 +1,22 @@
 class Solution {
-  public List<Integer> addToArrayForm(int[] num, int k) {
-    int carry = 0;
-    int idx = num.length - 1;
-    List<Integer> result = new ArrayList<>();
-    while (idx >= 0 || carry > 0 || k > 0) {
-      int temp = k % 10 + carry + (idx >= 0 ? num[idx--] : 0);
-      result.add(temp % 10);
-      carry = temp / 10;
-      k /= 10;
+    public List<Integer> addToArrayForm(int[] num, int k) {
+        List<Integer> result = new ArrayList<>();
+        int idx = num.length - 1;
+        int carry = 0;
+        while (idx >= 0 || k > 0 || carry > 0) {
+            if (idx >= 0 && k > 0) {
+                carry += num[idx--] + k % 10;
+                k /= 10;
+            } else if (idx >= 0 && k == 0) {
+                carry += num[idx--];
+            } else if (idx < 0 && k > 0) {
+                carry += k % 10;
+                k /= 10;
+            }
+            result.add(carry % 10);
+            carry /= 10;
+        }
+        Collections.reverse(result);
+        return result;
     }
-    Collections.reverse(result);
-    return result;
-  }
 }

From 3e3198b55f0d3166f08c5ab86352a665771d008d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 17 Feb 2023 06:36:40 -0800
Subject: [PATCH 1542/2175] Update Minimum Distance Between BST Nodes.java

---
 Easy/Minimum Distance Between BST Nodes.java | 35 +++++++++-----------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/Easy/Minimum Distance Between BST Nodes.java b/Easy/Minimum Distance Between BST Nodes.java
index 4c147e39..af92feb0 100644
--- a/Easy/Minimum Distance Between BST Nodes.java	
+++ b/Easy/Minimum Distance Between BST Nodes.java	
@@ -14,25 +14,22 @@
  * }
  */
 class Solution {
-  Integer minDiff;
-  Integer prev;
-  public int minDiffInBST(TreeNode root) {
-    minDiff = Integer.MAX_VALUE;
-    prev = null;
-    helper(root);
-    return minDiff;
-  }
-  
-  private void helper(TreeNode root) {
-    if (root == null) {
-      return;
+    public int minDiffInBST(TreeNode root) {
+        int[] minDiff = {Integer.MAX_VALUE};
+        Integer[] prevVal = {null};
+        inorder(root, minDiff, prevVal);
+        return minDiff[0];
     }
-    helper(root.left);
-    if (prev != null) {
-      minDiff = Math.min(minDiff, root.val - prev);
+    
+    private void inorder(TreeNode node, int[] minDiff, Integer[] prevValue) {
+        if (node == null) {
+            return;
+        }
+        inorder(node.left, minDiff, prevValue);
+        if (prevValue[0] != null) {
+            minDiff[0] = Math.min(minDiff[0], node.val - prevValue[0]);
+        }
+        prevValue[0] = node.val;
+        inorder(node.right, minDiff, prevValue);
     }
-    prev = root.val;
-    helper(root.right);
-  }
 }
-

From 2d13d75457e356dbe454eba180176f4f36650728 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Feb 2023 07:01:28 -0800
Subject: [PATCH 1543/2175] Update Invert Binary Tree.java

---
 Easy/Invert Binary Tree.java | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/Easy/Invert Binary Tree.java b/Easy/Invert Binary Tree.java
index f02950d0..d2c3c6ab 100644
--- a/Easy/Invert Binary Tree.java	
+++ b/Easy/Invert Binary Tree.java	
@@ -14,15 +14,13 @@
  * }
  */
 class Solution {
-  public TreeNode invertTree(TreeNode root) {
-    if (root == null) {
-      return root;
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) {
+            return null;
+        }
+        TreeNode leftNode = root.left;
+        root.left = invertTree(root.right);
+        root.right = invertTree(leftNode);
+        return root;
     }
-    TreeNode right = root.right;
-    root.right = root.left;
-    root.left = right;
-    invertTree(root.left);
-    invertTree(root.right);
-    return root;
-  }
 }

From 888e64c2bca1c5d0472848c3c46d8e25e170b232 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Feb 2023 07:48:29 -0800
Subject: [PATCH 1544/2175] Update Reshape the matrix.java

---
 Easy/Reshape the matrix.java | 41 ++++++++++++++----------------------
 1 file changed, 16 insertions(+), 25 deletions(-)

diff --git a/Easy/Reshape the matrix.java b/Easy/Reshape the matrix.java
index 1093a616..ca61f4e4 100644
--- a/Easy/Reshape the matrix.java	
+++ b/Easy/Reshape the matrix.java	
@@ -1,31 +1,22 @@
 class Solution {
-    public int[][] matrixReshape(int[][] nums, int r, int c) {
-        int numOfElem = nums.length*nums[0].length;
-        if (numOfElem != r*c) {
-            return nums;
+    public int[][] matrixReshape(int[][] mat, int r, int c) {
+        int m = mat.length;
+        int n = mat[0].length;
+        if (m * n != r * c) {
+            return mat;
         }
-        
-        int[] expandedArray = new int[numOfElem];
-        int k = 0;
-        
-        for (int i=0;i<nums.length;i++) {
-            for (int j=0;j<nums[i].length;j++) {
-                expandedArray[k] = nums[i][j];
-                k++;
+        int[][] result = new int[r][c];
+        int rowIdx = 0;
+        int colIdx = 0;
+        for (int i = 0; i < r; i++) {
+            for (int j = 0; j < c; j++) {
+                result[i][j] = mat[rowIdx][colIdx++];
+                if (colIdx == n) {
+                    colIdx = 0;
+                    rowIdx++;
+                }
             }
         }
-        
-        int[][] ans = new int[r][c];
-        int i=0;
-        int j=0;
-        for(k=0;k<numOfElem;k++) {
-            ans[i][j] = expandedArray[k];
-            j++;
-            if (j == c) {
-                j = 0;
-                i++;
-            }
-        }
-        return ans;
+        return result;
     }
 }

From 0f8b1ef4172cc6b271c775ce52470680a2ae71b0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 18 Feb 2023 07:51:15 -0800
Subject: [PATCH 1545/2175] Update Pascal's Triangle.java

---
 Easy/Pascal's Triangle.java | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/Easy/Pascal's Triangle.java b/Easy/Pascal's Triangle.java
index a64f8bd4..86ea8bdb 100644
--- a/Easy/Pascal's Triangle.java	
+++ b/Easy/Pascal's Triangle.java	
@@ -1,15 +1,17 @@
 class Solution {
-  public List<List<Integer>> generate(int numRows) {
-    List<List<Integer>> result = new ArrayList<>();
-    for (int i = 0; i < numRows; i++) {
-      List<Integer> temp = new ArrayList<>();
-      for (int j = 0; j <= i; j++) {
-        temp.add(
-          (j == 0 || j == i) ? 1 : 
-          (result.get(i - 1).get(j - 1) + result.get(i - 1).get(j)));
-      }
-      result.add(temp);
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = 0; i < numRows; i++) {
+            List<Integer> temp = new ArrayList<>();
+            for (int j = 0; j <= i; j++) {
+                if (j == 0 || j == i) {
+                    temp.add(1);
+                } else {
+                    temp.add(result.get(i - 1).get(j - 1) + result.get(i - 1).get(j));
+                }
+            }
+            result.add(temp);
+        }
+        return result;
     }
-    return result;
-  }
 }

From 5b7f7f5de5b85e3aa420e0223ec82615647694a1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 19 Feb 2023 13:32:39 -0800
Subject: [PATCH 1546/2175] Added Merge Two 2D Arrays by Summing Values.java

---
 ...Merge Two 2D Arrays by Summing Values.java | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Easy/Merge Two 2D Arrays by Summing Values.java

diff --git a/Easy/Merge Two 2D Arrays by Summing Values.java b/Easy/Merge Two 2D Arrays by Summing Values.java
new file mode 100644
index 00000000..87d07080
--- /dev/null
+++ b/Easy/Merge Two 2D Arrays by Summing Values.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int[][] mergeArrays(int[][] nums1, int[][] nums2) {
+        int[] totalSum = new int[1001];
+        int count = nums1.length;
+        for (int i = 0; i < nums1.length; i++) {
+            int id = nums1[i][0];
+            int val = nums1[i][1];
+            totalSum[id] = val;
+        }
+        for (int i = 0; i < nums2.length; i++) {
+            int id = nums2[i][0];
+            int val = nums2[i][1];
+            if (totalSum[id] == 0) {
+                count++;
+            }
+            totalSum[id] += val;
+        }
+        int[][] result = new int[count][2];
+        int idx = 0;
+        for (int i = 1; i <= 1000; i++) {
+            if (totalSum[i] != 0) {
+                result[idx++] = new int[]{i, totalSum[i]};
+            }
+        }
+        return result;
+    }
+}

From 698dadd406bcf0e6091890cd813e244c4d302a60 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 20 Feb 2023 15:50:52 -0800
Subject: [PATCH 1547/2175] Added Maximum Difference by Remapping a Digit

---
 ...ximum Difference by Remapping a Digit.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Maximum Difference by Remapping a Digit.java

diff --git a/Easy/Maximum Difference by Remapping a Digit.java b/Easy/Maximum Difference by Remapping a Digit.java
new file mode 100644
index 00000000..5241297f
--- /dev/null
+++ b/Easy/Maximum Difference by Remapping a Digit.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int minMaxDifference(int num) {
+        char digitsOne[] = String.valueOf(num).toCharArray();
+        char digitsTwo[] = String.valueOf(num).toCharArray();
+        char firstDigitOne = digitsOne[0];
+        char firstDigitTwo = digitsOne[0];
+        for (int i = 0; i < digitsOne.length; i++) {
+            if (digitsOne[i] != '9') {
+                firstDigitOne = digitsOne[i];
+                break;
+            }
+        }
+        for (int i = 0; i < digitsOne.length; i++) {
+            if (digitsOne[i] == firstDigitOne) {
+                digitsOne[i] = '9';
+            }
+        }
+        for(int i = 0; i < digitsOne.length; i++) {
+            if (digitsTwo[i] == firstDigitTwo) {
+                digitsTwo[i] = '0';
+            }
+        }
+        return Integer.parseInt(String.valueOf(digitsOne)) - Integer.parseInt(String.valueOf(digitsTwo));
+    }
+}

From 05a1586f1b4523f85f9f861ad51c4355090f6e0c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 20 Feb 2023 16:36:19 -0800
Subject: [PATCH 1548/2175] Updated Merge Two Sorted Lists.java

---
 Easy/Merge Two Sorted Lists.java | 56 +++++++++++++-------------------
 1 file changed, 23 insertions(+), 33 deletions(-)

diff --git a/Easy/Merge Two Sorted Lists.java b/Easy/Merge Two Sorted Lists.java
index cb2fff94..e594a670 100644
--- a/Easy/Merge Two Sorted Lists.java	
+++ b/Easy/Merge Two Sorted Lists.java	
@@ -9,39 +9,29 @@
  * }
  */
 class Solution {
-  public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
-    if (list1 == null || list2 == null) {
-      return list1 == null ? list2 : list1;
-    }
-    ListNode prev = null;
-    ListNode head = null;
-    while (list1 != null && list2 != null) {
-      if (list1.val <= list2.val) {
-        prev = list1;
-        if (head == null) {
-          head = list1;
-        }
-        list1 = list1.next;
-      } else {
-        ListNode node = list2;
-        list2 = list2.next;
-        if (prev == null) {
-          node.next = list1;
-          prev = node;
-          head = prev;
-        } else {
-          prev.next = node;
-          node.next = list1;
-          prev = node;
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode();
+        ListNode curr = dummy;
+        while (l1 != null || l2 != null) {
+            int val = -1;
+            if (l1 != null && l2 != null) {
+                if (l1.val > l2.val) {
+                    val = l2.val;
+                    l2 = l2.next;
+                } else {
+                    val = l1.val;
+                    l1 = l1.next;
+                }
+            } else if (l1 != null && l2 == null) {
+                val = l1.val;
+                l1 = l1.next;
+            } else {
+                val = l2.val;
+                l2 = l2.next;
+            }
+            curr.next = new ListNode(val);
+            curr = curr.next;
         }
-      }
-    }
-    if (list2 != null) {
-      prev.next = list2;
-    }
-    if (list1 != null) {
-      prev.next = list1;
+        return dummy.next;
     }
-    return head;
-  }
 }

From 325529cc8c40d2a54321708adcf6d75e779f2436 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 20 Feb 2023 17:44:04 -0800
Subject: [PATCH 1549/2175] Updated Single Element in a Sorted Array

---
 Medium/Single Element in a Sorted Array.java | 44 ++++++++++----------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/Medium/Single Element in a Sorted Array.java b/Medium/Single Element in a Sorted Array.java
index 3565e0b3..924794d3 100644
--- a/Medium/Single Element in a Sorted Array.java	
+++ b/Medium/Single Element in a Sorted Array.java	
@@ -1,25 +1,25 @@
 class Solution {
-  public int singleNonDuplicate(int[] nums) {
-    if (nums.length == 1) {
-      return nums[0];
+    public int singleNonDuplicate(int[] nums) {
+        int start = 0;
+        int end = nums.length - 1;
+        while (start < end) {
+            int mid = (end - start) / 2 + start;
+            if (nums[mid + 1] == nums[mid]) {
+                if ((end - mid) % 2 == 0) {
+                    start = mid + 2;
+                } else {
+                    end = mid - 1;
+                }               
+            } else if (nums[mid - 1] == nums[mid]) {
+                if ((end - mid) % 2 == 0) {
+                    end = mid - 2;
+                } else {
+                    start = mid + 1;
+                }
+            } else {
+                return nums[mid];
+            }
+        }
+        return nums[start];
     }
-    return binarySearchHelper(nums, 0, nums.length - 1);
-  }
-  
-  private int binarySearchHelper(int[] nums, int start, int end) {
-    if (start > end) {
-      return Integer.MIN_VALUE;
-    }
-    int mid = (start + end) / 2;
-    if (mid == 0 && mid + 1 < nums.length && nums[mid] != nums[mid + 1]) {
-      return nums[mid];
-    }
-    if (mid == nums.length - 1 && mid - 1 >= 0 && nums[mid] != nums[mid - 1]) {
-      return nums[mid];
-    }
-    if (mid + 1 < nums.length && nums[mid] != nums[mid + 1] && mid - 1 >= 0 && nums[mid] != nums[mid - 1]) {
-      return nums[mid];
-    }
-    return Math.max(binarySearchHelper(nums, start, mid - 1), binarySearchHelper(nums, mid + 1, end));
-  }
 }

From 244314f060c3b89916572a439c1ed7bfd0220b22 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 22 Feb 2023 19:59:10 -0800
Subject: [PATCH 1550/2175] Added IPO.java

---
 Hard/IPO.java | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Hard/IPO.java

diff --git a/Hard/IPO.java b/Hard/IPO.java
new file mode 100644
index 00000000..26cfaac8
--- /dev/null
+++ b/Hard/IPO.java
@@ -0,0 +1,31 @@
+class Solution {
+    public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
+        int n = profits.length;
+        Project[] projects = new Project[n];
+        int maximumCapital = w;
+        for (int i = 0; i < n; i++) {
+            projects[i] = new Project(capital[i], profits[i]);
+        }
+        Arrays.sort(projects);
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+        int idx = 0;
+        for (int i = 0; i < k; i++) {
+            while (idx < n && projects[idx].capital <= maximumCapital) {
+                pq.add(projects[idx++].profit);
+            }
+            if (pq.isEmpty()) {
+                break;
+            }
+            maximumCapital += pq.poll();
+        }
+        return maximumCapital;
+    }
+    
+    private record Project(int capital, int profit) implements Comparable<Project> {
+
+        @Override
+        public int compareTo(Project o) {
+            return capital - o.capital;
+        }
+    }
+}

From 1d92d5d1e5a0182c540ff6fcef5a7d9190d01fb4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 24 Feb 2023 06:30:26 -0800
Subject: [PATCH 1551/2175] Update Minimize Deviation in Array.java

---
 Hard/Minimize Deviation in Array.java | 36 +++++++++++++--------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/Hard/Minimize Deviation in Array.java b/Hard/Minimize Deviation in Array.java
index 736ccbd0..905621e6 100644
--- a/Hard/Minimize Deviation in Array.java	
+++ b/Hard/Minimize Deviation in Array.java	
@@ -1,21 +1,21 @@
 class Solution {
-  public int minimumDeviation(int[] nums) {
-    int currMinimum = Integer.MAX_VALUE;
-    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((a, b) -> b - a);
-    for (int num : nums) {
-      if (num % 2 != 0) {
-        num *= 2;
-      }
-      currMinimum = Math.min(currMinimum, num);
-      priorityQueue.add(num);
+    public int minimumDeviation(int[] nums) {
+        int currMinimum = Integer.MAX_VALUE;
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+        for (int num : nums) {
+            if (num % 2 != 0) {
+                num *= 2;
+            }
+            currMinimum = Math.min(currMinimum, num);
+            pq.add(num);
+        }
+        int deviation = Integer.MAX_VALUE;
+        while (pq.peek() % 2 == 0) {
+            int removed = pq.poll() / 2;
+            currMinimum = Math.min(currMinimum, removed);
+            pq.add(removed);
+            deviation = Math.min(deviation, pq.peek() - currMinimum);
+        }
+        return deviation;
     }
-    int deviation = Integer.MAX_VALUE;
-    while (priorityQueue.peek() % 2 == 0) {
-      int removed = priorityQueue.poll() / 2;
-      currMinimum = Math.min(currMinimum, removed);
-      priorityQueue.add(removed);
-      deviation = Math.min(deviation, priorityQueue.peek() - currMinimum);
-    }
-    return deviation;
-  }
 }

From 47e01c0983188538f8c087478b4c123d36be4a32 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 24 Feb 2023 07:27:59 -0800
Subject: [PATCH 1552/2175] Updated Symmetric Tree.java to iterative style

---
 Easy/Symmetric Tree.java | 37 ++++++++++++++++++++++++-------------
 1 file changed, 24 insertions(+), 13 deletions(-)

diff --git a/Easy/Symmetric Tree.java b/Easy/Symmetric Tree.java
index b20e39a5..929d6ade 100644
--- a/Easy/Symmetric Tree.java	
+++ b/Easy/Symmetric Tree.java	
@@ -12,19 +12,30 @@
  *         this.right = right;
  *     }
  * }
-*/
+ */
 class Solution {
-  public boolean isSymmetric(TreeNode root) {
-    return helper(root.left, root.right);
-  }
-  
-  private boolean helper(TreeNode leftNode, TreeNode rightNode) {
-    if (leftNode == null && rightNode == null) {
-      return true;
+    public boolean isSymmetric(TreeNode root) {
+        Queue<TreeNode[]> queue = new LinkedList<>();
+        queue.add(new TreeNode[]{root.left, root.right});
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                TreeNode[] removed = queue.remove();
+                TreeNode nodeOne = removed[0];
+                TreeNode nodeTwo = removed[1];
+                if (nodeOne == null && nodeTwo == null) {
+                    continue;
+                }
+                if (nodeOne == null || nodeTwo == null) {
+                    return false;
+                }
+                if (nodeOne.val != nodeTwo.val) {
+                    return false;
+                }
+                queue.add(new TreeNode[]{nodeOne.left, nodeTwo.right});
+                queue.add(new TreeNode[]{nodeOne.right, nodeTwo.left});
+            }
+        }
+        return true;
     }
-    if ((leftNode == null || rightNode == null) || leftNode.val != rightNode.val) {
-      return false;
-    }
-    return helper(leftNode.left, rightNode.right) && helper(leftNode.right, rightNode.left);
-  }
 }

From 927db22e2033d9a015d4ac5a98354d61dd571aa7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Feb 2023 07:43:57 -0800
Subject: [PATCH 1553/2175] Added Left and Right Sum Differences.java

---
 Easy/Left and Right Sum Differences.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Left and Right Sum Differences.java

diff --git a/Easy/Left and Right Sum Differences.java b/Easy/Left and Right Sum Differences.java
new file mode 100644
index 00000000..99a5338a
--- /dev/null
+++ b/Easy/Left and Right Sum Differences.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] leftRigthDifference(int[] nums) {
+        int n = nums.length;
+        int leftToRightSum = 0;
+        for (int i = 0; i < n; i++) {
+            leftToRightSum += nums[i];
+        }
+        int[] result = new int[n];
+        int rightToLeftSum = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            leftToRightSum -= nums[i];
+            result[i] = Math.abs(rightToLeftSum - leftToRightSum);
+            rightToLeftSum += nums[i];
+        }
+        return result;
+    }
+}

From 53da45bc0c044f5f368965d8fb7798e1e11b1f92 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Feb 2023 09:49:15 -0800
Subject: [PATCH 1554/2175] Modified Edit Distance.java to use top-down

---
 Hard/Edit Distance.java | 48 ++++++++++++++++++++++++-----------------
 1 file changed, 28 insertions(+), 20 deletions(-)

diff --git a/Hard/Edit Distance.java b/Hard/Edit Distance.java
index c4000645..b7ae5930 100644
--- a/Hard/Edit Distance.java	
+++ b/Hard/Edit Distance.java	
@@ -1,26 +1,34 @@
 class Solution {
-  public int minDistance(String word1, String word2) {
-    int n = word1.length();
-    int m = word2.length();
-    if (n * m == 0) {
-      return n + m;
+   public int minDistance(String word1, String word2) {
+        return minDistanceHelper(
+                word1, 
+                word2, 
+                word1.length(), 
+                word2.length(), 
+                new Integer[word1.length() + 1][word2.length() + 1]);
     }
-    int[][] dp = new int[n + 1][m + 1];
-    for (int i = 0; i <= n; i++) {
-      dp[i][0] = i;
-    }
-    for (int j = 0; j <= m; j++) {
-      dp[0][j] = j;
-    }
-    for (int i = 1; i <= n; i++) {
-      for (int j = 1; j <= m; j++) {
-        if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
-          dp[i][j] = dp[i - 1][j - 1];
+
+    private int minDistanceHelper(String word1, String word2, int word1Index, int word2Index, Integer[][] memo) {
+        if (word1Index == 0) {
+            return word2Index;
+        }
+        if (word2Index == 0) {
+            return word1Index;
+        }
+        if (memo[word1Index][word2Index] != null) {
+            return memo[word1Index][word2Index];
+        }
+        int minEditDistance = 0;
+        if (word1.charAt(word1Index - 1) == word2.charAt(word2Index - 1)) {
+            minEditDistance = minDistanceHelper(word1, word2, word1Index - 1, word2Index - 1, memo);
         } else {
-          dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;
+            int distanceWithInsertion = minDistanceHelper(word1, word2, word1Index, word2Index - 1, memo);
+            int distanceWithDeletion = minDistanceHelper(word1, word2, word1Index - 1, word2Index, memo);
+            int distanceWithReplace = minDistanceHelper(word1, word2, word1Index - 1, word2Index - 1, memo);
+            minEditDistance = Math.min(distanceWithInsertion, 
+                    Math.min(distanceWithDeletion, distanceWithReplace)) + 1;
         }
-      }
+        memo[word1Index][word2Index] = minEditDistance;
+        return minEditDistance;
     }
-    return dp[n][m];
-  }
 }

From 810f758e80a7b1a3503efeca72c7cad54f3587a5 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Feb 2023 14:31:05 -0800
Subject: [PATCH 1555/2175] Updated Design a File Sharing System.java

---
 Medium/Design a File Sharing System.java | 85 +++++++++++-------------
 1 file changed, 39 insertions(+), 46 deletions(-)

diff --git a/Medium/Design a File Sharing System.java b/Medium/Design a File Sharing System.java
index 2f6c3de7..b5bba82b 100644
--- a/Medium/Design a File Sharing System.java	
+++ b/Medium/Design a File Sharing System.java	
@@ -1,57 +1,50 @@
 class FileSharing {
-  Map<Integer, Set<Integer>> chunkToUserMap;
-  Map<Integer, Set<Integer>> userToChunkMap;
-  int id;
-  PriorityQueue<Integer> availableIds;
-  public FileSharing(int m) {
-    id = 1;
-    chunkToUserMap = new HashMap<>();
-    userToChunkMap = new HashMap<>();
-    for (int i = 1; i <= m; i++) {
-      chunkToUserMap.put(i, new HashSet<>());
-    }
-    availableIds = new PriorityQueue<>();
-  }
 
-  public int join(List<Integer> ownedChunks) {
-    int userId = getUserId();
-    userToChunkMap.put(userId, new HashSet<>(ownedChunks));
-    for (Integer chunk : ownedChunks) {
-      chunkToUserMap.get(chunk).add(userId);
-    }
-    return userId;
-  }
-  
-  private int getUserId() {
-    if (availableIds.isEmpty()) {
-      return id++;
+    private final PriorityQueue<Integer> userIdsInSystem;
+    private final Map<Integer, Set<Integer>> chunkToUserIdMapping;
+    private final Map<Integer, Set<Integer>> userIdToChunkMapping;
+
+    public FileSharing(int m) {
+        this.userIdsInSystem = new PriorityQueue<>();
+        this.userIdsInSystem.add(1);
+        this.chunkToUserIdMapping = new HashMap<>();
+        for (int i = 1; i <= m; i++) {
+            chunkToUserIdMapping.put(i, new HashSet<>());
+        }
+        this.userIdToChunkMapping = new HashMap<>();
     }
-    return availableIds.poll();
-  }
 
-  public void leave(int userID) {
-    Set<Integer> chunksOwned = userToChunkMap.get(userID);
-    userToChunkMap.remove(userID);
-    for (Integer chunk : chunksOwned) {
-      chunkToUserMap.get(chunk).remove(userID);
+    public int join(List<Integer> ownedChunks) {
+        int currUserId = this.userIdsInSystem.poll();
+        if (this.userIdsInSystem.isEmpty()) {
+            this.userIdsInSystem.add(currUserId + 1);
+        }
+        this.userIdToChunkMapping.computeIfAbsent(currUserId, k -> new HashSet<>());
+        for (Integer chunk : ownedChunks) {
+            this.chunkToUserIdMapping.get(chunk).add(currUserId);
+            this.userIdToChunkMapping.get(currUserId).add(chunk);
+        }
+        return currUserId;
     }
-    availableIds.add(userID);
-  }
 
-  public List<Integer> request(int userID, int chunkID) {
-    Set<Integer> usersOwningChunk = chunkToUserMap.get(chunkID);
-    Iterator<Integer> iterator = usersOwningChunk.iterator();
-    List<Integer> users = new ArrayList<>();
-    while (iterator.hasNext()) {
-      users.add(iterator.next());
+    public void leave(int userID) {
+        this.userIdsInSystem.add(userID);
+        Set<Integer> chunksOwned = this.userIdToChunkMapping.get(userID);
+        this.userIdToChunkMapping.remove(userID);
+        for (Integer chunk : chunksOwned) {
+            this.chunkToUserIdMapping.get(chunk).remove(userID);
+        }
     }
-    if (!usersOwningChunk.contains(userID) && usersOwningChunk.size() > 0) {
-      userToChunkMap.get(userID).add(chunkID);
-      chunkToUserMap.get(chunkID).add(userID);
+
+    public List<Integer> request(int userID, int chunkID) {
+        if (this.chunkToUserIdMapping.get(chunkID).isEmpty()) {
+            return new ArrayList<>();
+        }
+        List<Integer> usersOwningChunk = this.chunkToUserIdMapping.get(chunkID).stream().sorted().toList();
+        this.userIdToChunkMapping.get(userID).add(chunkID);
+        this.chunkToUserIdMapping.get(chunkID).add(userID);
+        return usersOwningChunk;
     }
-    Collections.sort(users);
-    return users;
-  }
 }
 
 /**

From 1e98fdc3096551c66e133562c022fd0e9988b391 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 27 Feb 2023 12:39:07 -0800
Subject: [PATCH 1556/2175] Updated Search in a Binary Search Tree to iterative

---
 Easy/Search in a Binary Search Tree.java | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/Easy/Search in a Binary Search Tree.java b/Easy/Search in a Binary Search Tree.java
index 63e2f736..e3c00460 100644
--- a/Easy/Search in a Binary Search Tree.java	
+++ b/Easy/Search in a Binary Search Tree.java	
@@ -14,13 +14,21 @@
  * }
  */
 class Solution {
-  public TreeNode searchBST(TreeNode root, int val) {
-    if (root == null) {
-      return root;
+    public TreeNode searchBST(TreeNode root, int val) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            TreeNode removed = queue.remove();
+            if (removed.val == val) {
+                return removed;
+            }
+            if (removed.val > val && removed.left != null) {
+                queue.add(removed.left);
+            } 
+            if (removed.val < val && removed.right != null) {
+                queue.add(removed.right);
+            }
+        }
+        return null;
     }
-    if (root.val == val) {
-      return root;
-    }
-    return root.val > val ? searchBST(root.left, val) : searchBST(root.right, val);
-  }
 }

From f195348c24a342a359567b22fd34bb1b510c2b91 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 28 Feb 2023 06:41:12 -0800
Subject: [PATCH 1557/2175] Updated Find Duplicate Subtrees.java

---
 Medium/Find Duplicate Subtrees.java | 45 ++++++++++++++---------------
 1 file changed, 21 insertions(+), 24 deletions(-)

diff --git a/Medium/Find Duplicate Subtrees.java b/Medium/Find Duplicate Subtrees.java
index b81a4bec..4800644b 100644
--- a/Medium/Find Duplicate Subtrees.java	
+++ b/Medium/Find Duplicate Subtrees.java	
@@ -4,35 +4,32 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    Map<String, TreeNode> map;
-    
     public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
-        map = new HashMap<>();
-        List<TreeNode> ans = new ArrayList<>();
-        
-        helper(root);
-        
-        for (TreeNode node : map.values()) {
-            if (node != null) {
-                ans.add(node);
-            }
-        }
-        
-        return ans;
+        List<TreeNode> result = new LinkedList<>();
+        traverse(root, new HashMap<>(), result);
+        return result;
     }
-
-    private String helper(TreeNode root) {
-        if (root == null) {
-            return "#";
+    
+    private String traverse(TreeNode node, Map<String, Integer> frequencyMap, List<TreeNode> result) {
+        if (node == null) {
+            return "";
+        }
+        String key = ("(" + traverse(node.left, frequencyMap, result) + ")" + node.val + 
+                      "(" + traverse(node.right, frequencyMap, result) + ")");
+        frequencyMap.put(key, frequencyMap.getOrDefault(key, 0) + 1);
+        if (frequencyMap.get(key) == 2) {
+            result.add(node);
         }
-        
-        String path = root.val + "|" + helper(root.left) + "|" + helper(root.right);
-        map.put(path, map.containsKey(path) ? root : null);
-        
-        return path;
+        return key;
     }
 }

From 32a5bef670a17c7a973a8be96f7da57e8edf5ed7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 28 Feb 2023 09:04:22 -0800
Subject: [PATCH 1558/2175] Updated 3Sum.java

---
 Medium/3Sum.java | 38 +++++++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/Medium/3Sum.java b/Medium/3Sum.java
index fc4f25fa..3c615e51 100644
--- a/Medium/3Sum.java
+++ b/Medium/3Sum.java
@@ -1,21 +1,25 @@
 class Solution {
-  public List<List<Integer>> threeSum(int[] nums) {
-    Set<List<Integer>> result = new HashSet<>();
-    Set<Integer> duplicates = new HashSet<>();
-    Map<Integer, Integer> map = new HashMap<>();
-    for (int i = 0; i < nums.length; i++) {
-      if (duplicates.add(nums[i])) {
-        for (int j = i + 1; j < nums.length; j++) {
-          int target = -nums[i] - nums[j];
-          if (map.containsKey(target) && map.get(target) == i) {
-            List<Integer> temp = Arrays.asList(nums[i], nums[j], target);
-            Collections.sort(temp);
-            result.add(temp);
-          }
-          map.put(nums[j], i);
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = 0; i < nums.length; i++) {
+            if (i != 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+            int low = i + 1;
+            int high = nums.length - 1;
+            while (low < high) {
+                int currSum = nums[low] + nums[high] + nums[i];
+                if (currSum > 0 || (high < nums.length - 1 && nums[high] == nums[high + 1])) {
+                    high--;
+                } else if (currSum < 0 || (low > i + 1 && nums[low] == nums[low - 1])) {
+                    low++;
+                } else {
+                    result.add(Arrays.asList(nums[i], nums[low++], nums[high--]));
+                }
+                
+            }
         }
-      }
+        return result;
     }
-    return new ArrayList<>(result);
-  }
 }

From 0faa2f57c2d5132d784e990e4050703d9a22ac57 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 28 Feb 2023 13:01:26 -0800
Subject: [PATCH 1559/2175] Create Smallest Number in Infinite Set.java

---
 Medium/Smallest Number in Infinite Set.java | 34 +++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Smallest Number in Infinite Set.java

diff --git a/Medium/Smallest Number in Infinite Set.java b/Medium/Smallest Number in Infinite Set.java
new file mode 100644
index 00000000..2555f5ce
--- /dev/null
+++ b/Medium/Smallest Number in Infinite Set.java	
@@ -0,0 +1,34 @@
+class SmallestInfiniteSet {
+    
+    private final PriorityQueue<Integer> pq;
+    private int current;
+    
+    public SmallestInfiniteSet() {
+        this.pq = new PriorityQueue<>();
+        this.current = 1;
+    }
+    
+    public int popSmallest() {
+        int result = current;
+        if (!pq.isEmpty() && pq.peek() < current) {
+            result = pq.poll();  
+        } else {
+            current++;
+        }
+        while (!pq.isEmpty() && pq.peek() == result) {
+            pq.poll();
+        }
+        return result;
+    }
+    
+    public void addBack(int num) {
+        pq.add(num);
+    }
+}
+
+/**
+ * Your SmallestInfiniteSet object will be instantiated and called as such:
+ * SmallestInfiniteSet obj = new SmallestInfiniteSet();
+ * int param_1 = obj.popSmallest();
+ * obj.addBack(num);
+ */

From 96456396916637efbd8750f300bd4eb1a2544d28 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 28 Feb 2023 16:23:55 -0800
Subject: [PATCH 1560/2175] Update Sort An Array.java

---
 Medium/Sort An Array.java | 67 +++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 34 deletions(-)

diff --git a/Medium/Sort An Array.java b/Medium/Sort An Array.java
index 7c3f105e..a906afc4 100644
--- a/Medium/Sort An Array.java	
+++ b/Medium/Sort An Array.java	
@@ -1,40 +1,39 @@
 class Solution {
-  public int[] sortArray(int[] nums) {
-    int n = nums.length - 1;
-    mergeSort(nums, 0, n);
-    return nums;
-  }
-  
-  private void mergeSort(int[] nums, int start, int end) {
-    if (end - start + 1 <= 1) {
-      return;
+    public int[] sortArray(int[] nums) {
+        mergeSort(nums, 0, nums.length - 1);
+        return nums;
     }
-    int mid = start + (end - start) / 2;
-    mergeSort(nums, start, mid);
-    mergeSort(nums, mid + 1, end);
-    merge(nums, start, mid, end);
-  }
   
-  private void merge(int[] nums, int start, int mid, int end) {
-    int left = start;
-    int right = mid + 1;
-    int[] temp = new int[end - start + 1];
-    int idx = 0;
-    while (left <= mid && right <= end) {
-      if (nums[left] < nums[right]) {
-        temp[idx++] = nums[left++];
-      } else {
-        temp[idx++] = nums[right++];
-      }
-    }
-    while (left <= mid) {
-      temp[idx++] = nums[left++];
+    private void mergeSort(int[] nums, int start, int end) {
+        if (end - start <= 0) {
+            return;
+        }
+        int mid = start + (end - start) / 2;
+        mergeSort(nums, start, mid);
+        mergeSort(nums, mid + 1, end);
+        merge(nums, start, mid, end);
     }
-    while (right <= end) {
-      temp[idx++] = nums[right++];
-    }
-    for (int i = start; i <= end; i++) {
-      nums[i] = temp[i - start];
+  
+    private void merge(int[] nums, int start, int mid, int end) {
+        int left = start;
+        int right = mid + 1;
+        int[] temp = new int[end - start + 1];
+        int idx = 0;
+        while (left <= mid && right <= end) {
+            if (nums[left] < nums[right]) {
+                temp[idx++] = nums[left++];
+            } else {
+                temp[idx++] = nums[right++];
+            }
+        }
+        while (left <= mid) {
+            temp[idx++] = nums[left++];
+        }
+        while (right <= end) {
+            temp[idx++] = nums[right++];
+        }
+        for (int i = start; i <= end; i++) {
+            nums[i] = temp[i - start];
+        }
     }
-  }
 }

From 701b492cca15c9ae51364a99939bb6e010231c77 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Mar 2023 10:22:10 -0800
Subject: [PATCH 1561/2175] Update Snapshot Array.java

---
 Medium/Snapshot Array.java | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/Medium/Snapshot Array.java b/Medium/Snapshot Array.java
index d735dde3..282b6476 100644
--- a/Medium/Snapshot Array.java	
+++ b/Medium/Snapshot Array.java	
@@ -1,26 +1,28 @@
 class SnapshotArray {
-  TreeMap<Integer, Integer>[] A;
-  int snapId;
-  public SnapshotArray(int length) {
-    A = new TreeMap[length];
-    snapId = 0;
-    for (int i = 0; i < length; i++) {
-      A[i] = new TreeMap<Integer, Integer>();
-      A[i].put(0, 0);
+    
+    private final TreeMap<Integer, Integer>[] db;
+    private int currentSnapId;
+
+    public SnapshotArray(int length) {
+        db = new TreeMap[length];
+        for (int i = 0; i < length; i++) {
+            db[i] = new TreeMap<Integer, Integer>();
+            db[i].put(0, 0);
+        }
+        this.currentSnapId = 0;
     }
-  }
 
-  public void set(int index, int val) {
-    A[index].put(snapId, val);
-  }
+    public void set(int index, int val) {
+        db[index].put(currentSnapId, val);
+    }
 
-  public int snap() {
-    return snapId++;
-  }
+    public int snap() {
+        return currentSnapId++;
+    }
 
-  public int get(int index, int snap_id) {
-    return A[index].floorEntry(snap_id).getValue();
-  }
+    public int get(int index, int snap_id) {
+        return db[index].floorEntry(snap_id).getValue();
+    }
 }
 
 /**

From 9e9de5a770cd44269526d201256e9a1ad9e2eca2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Mar 2023 14:19:09 -0800
Subject: [PATCH 1562/2175] Update Valid Word Square.java

---
 Easy/Valid Word Square.java | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/Easy/Valid Word Square.java b/Easy/Valid Word Square.java
index 392d8392..0226d4d5 100644
--- a/Easy/Valid Word Square.java	
+++ b/Easy/Valid Word Square.java	
@@ -1,13 +1,23 @@
 class Solution {
     public boolean validWordSquare(List<String> words) {
-        int n = words.size();
-        for (int i = 0; i < n; i++){
-            for (int j = 0; j < words.get(i).length(); j++){
-                if(j >= n || words.get(j).length() <= i || words.get(j).charAt(i) != words.get(i).charAt(j)) {
-                    return false;
-                }
+        int column = 0;
+        for (String rowWord : words) {
+            String columnWord = getColumnWord(words, column++);
+            if (!rowWord.equals(columnWord)) {
+                return false;
             }
         }
         return true;
     }
+    
+    private String getColumnWord(List<String> words, int column) {
+        StringBuilder sb = new StringBuilder();
+        for (String word : words) {
+            if (column >= word.length()) {
+                break;
+            }
+            sb.append(word.charAt(column));
+        }
+        return sb.toString();
+    }
 }

From 6d98b0acf584ad06ac2e346602eabbfe56492a20 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Mar 2023 16:38:55 -0800
Subject: [PATCH 1563/2175] Update String Compression.java

---
 Medium/String Compression.java | 35 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git a/Medium/String Compression.java b/Medium/String Compression.java
index 182df66f..060e655e 100644
--- a/Medium/String Compression.java	
+++ b/Medium/String Compression.java	
@@ -1,22 +1,21 @@
 class Solution {
-  public int compress(char[] chars) {
-    int idx = 0;
-    int startIdx = 0;
-    while (idx < chars.length) {
-      char c = chars[idx];
-      int count = 0;
-      while (idx < chars.length && chars[idx] == c) {
-        idx++;
-        count++;
-      }
-      chars[startIdx++] = c;
-      if (count > 1) {
-        String countString = String.valueOf(count);
-        for (char cs : countString.toCharArray()) {
-          chars[startIdx++] = cs;
+    public int compress(char[] chars) {
+        int startIdx = 0;
+        for (int i = 0; i < chars.length;) {
+            char c = chars[i];
+            int count = 0;
+            while (i < chars.length && chars[i] == c) {
+                count++;
+                i++;
+            }
+            chars[startIdx++] = c;
+            if (count > 1) {
+                String temp = String.valueOf(count);
+                for (char digit : temp.toCharArray()) {
+                    chars[startIdx++] = digit;
+                }
+            }
         }
-      }
+        return startIdx;
     }
-    return startIdx;
-  }
 }

From e3fbc59aee6b6786bf7263c740613949c9a6f162 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 2 Mar 2023 15:23:23 -0800
Subject: [PATCH 1564/2175] Update Majority Element II.java

---
 Medium/Majority Element II.java | 79 +++++++++++++++++----------------
 1 file changed, 40 insertions(+), 39 deletions(-)

diff --git a/Medium/Majority Element II.java b/Medium/Majority Element II.java
index a44275b4..5b59752e 100644
--- a/Medium/Majority Element II.java	
+++ b/Medium/Majority Element II.java	
@@ -1,42 +1,43 @@
 class Solution {
-  public List<Integer> majorityElement(int[] nums) {
-    Integer majorityElementOne = null;
-    Integer majorityElementTwo = null;
-    int countOne = 0;
-    int countTwo = 0;
-    for (int num : nums) {
-      if (majorityElementOne != null && num == majorityElementOne) {
-        countOne++;
-      } else if (majorityElementTwo != null && num == majorityElementTwo) {
-        countTwo++;
-      } else if (countOne == 0) {
-        majorityElementOne = num;
-        countOne = 1;
-      } else if (countTwo == 0) {
-        majorityElementTwo = num;
-        countTwo = 1;
-      } else {
-        countOne--;
-        countTwo--;
-      }
+    public List<Integer> majorityElement(int[] nums) {
+        Integer candidateOne = null;
+        Integer candidateTwo = null;
+        int countOne = 0;
+        int countTwo = 0;
+        for (int num : nums) {
+            if (candidateOne != null && candidateOne == num) {
+                countOne++;
+            } else if (candidateTwo != null && candidateTwo == num) {
+                countTwo++;
+            } else if (countOne == 0) {
+                candidateOne = num;
+                countOne++;
+            } else if (countTwo == 0) {
+                candidateTwo = num;
+                countTwo++;
+            } else {
+                countOne--;
+                countTwo--;
+            }
+        }
+        countOne = 0;
+        countTwo = 0;
+        for (int num : nums) {
+            if (candidateOne != null && candidateOne == num) {
+                countOne++;
+            }
+            if (candidateTwo != null && candidateTwo == num) {
+                countTwo++;
+            }
+        }
+        int n = nums.length;
+        List<Integer> result = new ArrayList<>();
+        if (countOne > n / 3) {
+            result.add(candidateOne);
+        }
+        if (countTwo > n / 3) {
+            result.add(candidateTwo);
+        }
+        return result;
     }
-    List<Integer> result = new ArrayList<>();
-    countOne = 0;
-    countTwo = 0;
-    for (int num : nums) {
-      if (majorityElementOne != null && majorityElementOne == num) {
-        countOne++;
-      }
-      if (majorityElementTwo != null && majorityElementTwo == num) {
-        countTwo++;
-      }
-    }
-    if (countOne > nums.length / 3) {
-      result.add(majorityElementOne);
-    }
-    if (countTwo > nums.length / 3) {
-      result.add(majorityElementTwo);
-    }
-    return result;
-  }
 }

From a269fd566dba3b6aa0bac12af2a9693e009d5f24 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 2 Mar 2023 17:41:32 -0800
Subject: [PATCH 1565/2175] Added Find the Index of the First Occurrence in a
 String

---
 ... the Index of the First Occurrence in a String.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Medium/Find the Index of the First Occurrence in a String.java

diff --git a/Medium/Find the Index of the First Occurrence in a String.java b/Medium/Find the Index of the First Occurrence in a String.java
new file mode 100644
index 00000000..4156d0ba
--- /dev/null
+++ b/Medium/Find the Index of the First Occurrence in a String.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public int strStr(String haystack, String needle) {
+        for (int i = 0; i <= haystack.length() - needle.length(); i++) {
+            if (haystack.substring(i, i + needle.length()).equals(needle)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

From 613eb298b5fd1c6bb1330ba14ab90e0821333507 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 4 Mar 2023 12:00:07 -0800
Subject: [PATCH 1566/2175] Added Count Subarrays With Fixed Bounds.java

---
 Hard/Count Subarrays With Fixed Bounds.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Hard/Count Subarrays With Fixed Bounds.java

diff --git a/Hard/Count Subarrays With Fixed Bounds.java b/Hard/Count Subarrays With Fixed Bounds.java
new file mode 100644
index 00000000..2846d647
--- /dev/null
+++ b/Hard/Count Subarrays With Fixed Bounds.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public long countSubarrays(int[] nums, int minK, int maxK) {
+        long result = 0;
+        int minPosition = -1;
+        int maxPosition = -1;
+        int leftIdx = -1;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] < minK || nums[i] > maxK) {
+                leftIdx = i;
+            }
+            if (nums[i] == minK) {
+                minPosition = i;
+            }
+            if (nums[i] == maxK) {
+                maxPosition = i;
+            }
+            result += Math.max(0, Math.min(maxPosition, minPosition) - leftIdx);
+        }
+        return result;
+    }
+}

From 56629ad0d6abb90ec8e4cb4a783e94e95004135d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 5 Mar 2023 07:21:38 -0800
Subject: [PATCH 1567/2175] Added Jump Game IV

---
 Hard/Jump Game IV.java | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Hard/Jump Game IV.java

diff --git a/Hard/Jump Game IV.java b/Hard/Jump Game IV.java
new file mode 100644
index 00000000..960ce4b7
--- /dev/null
+++ b/Hard/Jump Game IV.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public int minJumps(int[] arr) {
+        int n = arr.length;
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            graph.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i);
+        }
+        Queue<Integer> path = new LinkedList<>();
+        Set<Integer> visited = new HashSet<>();
+        path.add(0);
+        int steps = 0;
+        while (!path.isEmpty()) {
+            int size = path.size();
+            while (size-- > 0) {
+                int removed = path.remove();
+                if (removed == n - 1) {
+                    return steps;
+                }
+                for (Integer child : graph.get(arr[removed])) {
+                    if (!visited.contains(child)) {
+                        visited.add(child);
+                        path.add(child);
+                    }
+                }
+                graph.get(arr[removed]).clear();
+                if (removed + 1 < n && !visited.contains(removed + 1)) {
+                    visited.add(removed + 1);
+                    path.add(removed + 1);
+                }
+                if (removed - 1 >= 0 && !visited.contains(removed - 1)) {
+                    visited.add(removed - 1);
+                    path.add(removed - 1);
+                }
+            }
+            steps++;
+        }
+        return -1;
+    }
+}

From 1357acfbe52974366ce73cf9fa75be37ce33e035 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 5 Mar 2023 14:15:35 -0800
Subject: [PATCH 1568/2175] Added Pass the Pillow

---
 Easy/Pass the Pillow.java | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Easy/Pass the Pillow.java

diff --git a/Easy/Pass the Pillow.java b/Easy/Pass the Pillow.java
new file mode 100644
index 00000000..e9ae16ea
--- /dev/null
+++ b/Easy/Pass the Pillow.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int passThePillow(int n, int time) {
+        int factor = time / (n - 1);
+        int remainder = time % (n - 1);
+        return factor % 2 != 0 ? (n - remainder) : (1 + remainder);
+    }
+}

From 6e71fbed13f389fec45c81356bae45542fe61627 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 6 Mar 2023 19:53:48 -0800
Subject: [PATCH 1569/2175] Updated Minimum Time to Complete Trips.java

---
 Medium/Minimum Time to Complete Trips.java | 46 +++++++++++-----------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/Medium/Minimum Time to Complete Trips.java b/Medium/Minimum Time to Complete Trips.java
index 901a3e57..f6fa3539 100644
--- a/Medium/Minimum Time to Complete Trips.java	
+++ b/Medium/Minimum Time to Complete Trips.java	
@@ -1,27 +1,27 @@
 class Solution {
-  public long minimumTime(int[] time, int totalTrips) {
-    long minTime = 1;
-    long fastestBus = time[0];
-    for (int t : time) {
-      fastestBus = Math.min(fastestBus, t);
+    public long minimumTime(int[] time, int totalTrips) {
+        int maxTime = 1;
+        for (int t : time) {
+            maxTime = Math.max(maxTime, t);
+        }
+        long left = 1;
+        long right = (long) maxTime * totalTrips;
+        while (left < right) {
+            long mid = (left + right) / 2;
+            if (isPossible(time, mid, totalTrips)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
     }
-    long maxTime = fastestBus * totalTrips;
-    while (minTime < maxTime) {
-      long midTime = minTime + (maxTime - minTime) / 2;
-      if (getNumberOfTripsWithTime(time, midTime) >= totalTrips) {
-        maxTime = midTime;
-      } else {
-        minTime = midTime + 1;
-      }
+    
+    private boolean isPossible(int[] time, long totalTime, int totalTrips) {
+        long actualTrips = 0;
+        for (int t : time) {
+            actualTrips += totalTime / t;
+        }
+        return actualTrips >= totalTrips;
     }
-    return minTime;
-  }
-  
-  private long getNumberOfTripsWithTime(int[] time, long currentTime) {
-    long totalTrips = 0;
-    for (int t : time) {
-      totalTrips += currentTime / t;
-    }
-    return totalTrips;
-  }
 }

From 96d75c9a8bb926acb97af2756b5224458fe5cdba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Mar 2023 08:19:27 -0800
Subject: [PATCH 1570/2175] Create Split With Minimum Sum.java

---
 Easy/Split With Minimum Sum.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Split With Minimum Sum.java

diff --git a/Easy/Split With Minimum Sum.java b/Easy/Split With Minimum Sum.java
new file mode 100644
index 00000000..3f816605
--- /dev/null
+++ b/Easy/Split With Minimum Sum.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int splitNum(int num) {
+        List<Integer> digits = new ArrayList<>();
+        while (num > 0) {
+            digits.add(num % 10);
+            num /= 10;
+        }
+        Collections.sort(digits);
+        int numOne = 0;
+        int numTwo = 0;
+        boolean flag = true;
+        for (int digit : digits) {
+            if (flag) {
+                numOne = numOne * 10 + digit;
+            } else {
+                numTwo = numTwo * 10 + digit;
+            }
+            flag = !flag;
+        }
+        return numOne + numTwo;
+    }
+}

From bef17f87c83f6c619b1c1c8b4240994015640712 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 7 Mar 2023 15:45:06 -0800
Subject: [PATCH 1571/2175] Create Kth Largest Sum in a Binary Tree.java

---
 Medium/Kth Largest Sum in a Binary Tree.java | 41 ++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Medium/Kth Largest Sum in a Binary Tree.java

diff --git a/Medium/Kth Largest Sum in a Binary Tree.java b/Medium/Kth Largest Sum in a Binary Tree.java
new file mode 100644
index 00000000..01955179
--- /dev/null
+++ b/Medium/Kth Largest Sum in a Binary Tree.java	
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public long kthLargestLevelSum(TreeNode root, int k) {
+        PriorityQueue<Long> pq = new PriorityQueue<>();
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            long sum = 0l;
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                sum += removed.val;
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            pq.add(sum);
+            if (pq.size() > k) {
+                pq.poll();
+            }
+        }
+        return pq.size() < k ? -1 : pq.poll();
+    }
+}

From 139f4792b78f4d940221ab535201178cc92bacec Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 8 Mar 2023 17:47:09 -0800
Subject: [PATCH 1572/2175] Updated Linked List Cycle II

---
 Medium/Linked List Cycle II.java | 38 ++++++++++++++++----------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/Medium/Linked List Cycle II.java b/Medium/Linked List Cycle II.java
index 42ba6ee8..2a88b1b4 100644
--- a/Medium/Linked List Cycle II.java	
+++ b/Medium/Linked List Cycle II.java	
@@ -10,24 +10,24 @@
  * }
  */
 public class Solution {
-  public ListNode detectCycle(ListNode head) {
-    ListNode fast = head;
-    ListNode slow = head;
-    while (fast != null && fast.next != null) {
-      slow = slow.next;
-      fast = fast.next.next;
-      if (slow == fast) {
-        break;
-      }
+    public ListNode detectCycle(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+            if (slow == fast) {
+                break;
+            }
+        }
+        if (fast == null || fast.next == null) {
+            return null;
+        }
+        ListNode curr = head;
+        while (curr != slow) {
+            curr = curr.next;
+            slow = slow.next;
+        }
+        return curr;
     }
-    if (fast == null || fast.next == null) {
-      return null;
-    }
-    slow = head;
-    while (slow != fast) {
-      slow = slow.next;
-      fast = fast.next;
-    }
-    return slow;
-  }
 }

From 57b4c08942fa7fb65979824c8a345ea1bd62e5f4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Mar 2023 16:58:48 -0800
Subject: [PATCH 1573/2175] Update Shortest Way to Form String.java

---
 Medium/Shortest Way to Form String.java | 43 +++++++++++--------------
 1 file changed, 19 insertions(+), 24 deletions(-)

diff --git a/Medium/Shortest Way to Form String.java b/Medium/Shortest Way to Form String.java
index c5f28f1f..e87eaf33 100644
--- a/Medium/Shortest Way to Form String.java	
+++ b/Medium/Shortest Way to Form String.java	
@@ -1,28 +1,23 @@
 class Solution {
-  public int shortestWay(String source, String target) {
-    int count = 1;
-    int idx = 0;
-    int n = target.length();
-    int sourceIdx = 0;
-    boolean match = false;
-    while (idx < n) {
-      if (source.charAt(sourceIdx) == target.charAt(idx)) {
-        idx++;
-        sourceIdx++;
-        match = true;
-      }
-      else {
-        sourceIdx++;
-      }
-      if (sourceIdx == source.length() && idx != n) {
-        if (!match) {
-          return -1;
+    public int shortestWay(String source, String target) {
+        Set<Character> letters = source.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
+        int count = 0;
+        int sourceIdx = 0;
+        int targetIdx = 0;
+        while (targetIdx < target.length()) {
+            char targetLetter = target.charAt(targetIdx);
+            if (!letters.contains(targetLetter)) {
+                return -1;
+            }
+            if (targetLetter == source.charAt(sourceIdx)) {
+                targetIdx++;
+            }
+            sourceIdx++;
+            if (sourceIdx == source.length()) {
+                sourceIdx = 0;
+                count++;
+            }
         }
-        count++;
-        sourceIdx = 0;
-        match = false;
-      }
+        return count + (sourceIdx == 0 ? 0 : 1);
     }
-    return count;
-  }
 }

From 7e3c64027a5d9b029e5569631270eca184beafbb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 11 Mar 2023 07:46:43 -0800
Subject: [PATCH 1574/2175] Updated Convert Sorted List to Binary Search
 Tree.java

---
 ...ert Sorted List to Binary Search Tree.java | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/Medium/Convert Sorted List to Binary Search Tree.java b/Medium/Convert Sorted List to Binary Search Tree.java
index 5b49c0f3..c1258059 100644
--- a/Medium/Convert Sorted List to Binary Search Tree.java	
+++ b/Medium/Convert Sorted List to Binary Search Tree.java	
@@ -3,7 +3,9 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 /**
@@ -12,35 +14,33 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    ListNode curr;
-    
-    public TreeNode sortedListToBST(ListNode head) {        
-        curr = head;
-        return generate(count(head));
-    }
-    
-    public int count(ListNode node) {
-        int n = 0;
-        while (node != null) {
-            node = node.next;
-            ++n;
+    public TreeNode sortedListToBST(ListNode head) {
+        List<Integer> list = new ArrayList<>();
+        while (head != null) {
+            list.add(head.val);
+            head = head.next;
         }
-        return n;
+        return helper(list, 0, list.size() - 1);
     }
     
-    public TreeNode generate(int n) {
-        if (n==0) return null;
-        
-        TreeNode node = new TreeNode(0);
-        node.left = generate(n/2);
-        node.val = curr.val;
-        curr = curr.next;
-        node.right = generate(n-(n/2)-1);
-        
-        return node;
+    private TreeNode helper(List<Integer> list, int start, int end) {
+        if (start > end) {
+            return null;
+        }
+        int mid = (start + end) / 2;
+        TreeNode root = new TreeNode(list.get(mid));
+        root.left = helper(list, start, mid - 1);
+        root.right = helper(list, mid + 1, end);
+        return root;
     }
 }

From a62cb373579970d281b2d14f377a9b14300ebd25 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 12 Mar 2023 07:58:56 -0700
Subject: [PATCH 1575/2175] Added Count the Number of Vowel Strings in
 Range.java

---
 Easy/Count the Number of Vowel Strings in Range.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Count the Number of Vowel Strings in Range.java

diff --git a/Easy/Count the Number of Vowel Strings in Range.java b/Easy/Count the Number of Vowel Strings in Range.java
new file mode 100644
index 00000000..38eeb76e
--- /dev/null
+++ b/Easy/Count the Number of Vowel Strings in Range.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public int vowelStrings(String[] words, int left, int right) {
+        Set<Character> vowels = Set.of('a', 'e', 'i', 'o', 'u');
+        return (int) Arrays.stream(words)
+                .skip(left)
+                .limit(right - left + 1)
+                .filter(word -> vowels.contains(word.charAt(0)) && vowels.contains(word.charAt(word.length() - 1)))
+                .count();
+    }
+}

From 5f47791115ab26d68bb2b7909a9c60124f709afc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 12 Mar 2023 18:19:12 -0700
Subject: [PATCH 1576/2175] Updated README

---
 Easy/README.md   |  895 ++++++++++++++++++++--------------------
 Hard/README.md   |  171 ++++----
 Medium/README.md | 1024 +++++++++++++++++++++++-----------------------
 3 files changed, 1051 insertions(+), 1039 deletions(-)

diff --git a/Easy/README.md b/Easy/README.md
index 63afc542..23f8ec11 100644
--- a/Easy/README.md
+++ b/Easy/README.md
@@ -113,448 +113,453 @@ S.no | Coding Problem
 110 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
 111 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java)
 112 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
-113 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java)
-114 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
-115 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java)
-116 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
-117 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
-118 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
-119 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
-120 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
-121 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
-122 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
-123 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java)
-124 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
-125 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
-126 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
-127 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
-128 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
-129 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
-130 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
-131 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
-132 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java)
-133 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
-134 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
-135 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
-136 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
-137 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
-138 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java)
-139 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
-140 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
-141 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
-142 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
-143 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
-144 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
-145 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
-146 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java)
-147 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
-148 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
-149 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java)
-150 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
-151 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
-152 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
-153 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java)
-154 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java)
-155 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
-156 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
-157 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
-158 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
-159 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java)
-160 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
-161 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
-162 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
-163 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
-164 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java)
-165 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
-166 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java)
-167 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java)
-168 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
-169 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
-170 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
-171 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java)
-172 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
-173 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java)
-174 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
-175 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
-176 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
-177 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
-178 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
-179 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
-180 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
-181 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
-182 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java)
-183 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
-184 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java)
-185 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java)
-186 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
-187 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
-188 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java)
-189 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java)
-190 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java)
-191 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
-192 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
-193 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java)
-194 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java)
-195 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
-196 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
-197 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java)
-198 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
-199 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java)
-200 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
-201 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
-202 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
-203 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
-204 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
-205 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
-206 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
-207 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
-208 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
-209 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
-210 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
-211 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
-212 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java)
-213 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
-214 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
-215 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
-216 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
-217 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
-218 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
-219 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
-220 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
-221 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
-222 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
-223 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
-224 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
-225 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
-226 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
-227 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
-228 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
-229 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
-230 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java)
-231 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
-232 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java)
-233 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
-234 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
-235 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
-236 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
-237 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
-238 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
-239 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
-240 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
-241 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
-242 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java)
-243 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
-244 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
-245 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java)
-246 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
-247 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
-248 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java)
-249 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java)
-250 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java)
-251 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
-252 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
-253 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
-254 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java)
-255 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
-256 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
-257 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
-258 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
-259 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
-260 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
-261 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
-262 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
-263 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
-264 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
-265 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
-266 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
-267 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
-268 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
-269 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
-270 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
-271 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
-272 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
-273 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
-274 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java)
-275 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
-276 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
-277 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
-278 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
-279 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
-280 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
-281 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
-282 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java)
-283 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
-284 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
-285 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
-286 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
-287 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java)
-288 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
-289 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
-290 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
-291 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java)
-292 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
-293 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java)
-294 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
-295 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java)
-296 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
-297 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
-298 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
-299 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java)
-300 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java)
-301 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
-302 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
-303 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
-304 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java)
-305 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
-306 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
-307 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
-308 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java)
-309 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
-310 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java)
-311 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
-312 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
-313 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
-314 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java)
-315 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
-316 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
-317 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
-318 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
-319 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
-320 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
-321 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java)
-322 | [Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
-323 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
-324 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java)
-325 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java)
-326 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
-327 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java)
-328 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java)
-329 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java)
-330 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java)
-331 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
-332 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
-333 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
-334 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
-335 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java)
-336 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
-337 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java)
-338 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
-339 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java)
-340 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java)
-341 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
-342 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java)
-343 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
-344 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java)
-345 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
-346 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
-347 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
-348 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
-349 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
-350 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
-351 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java)
-352 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
-353 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
-354 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java)
-355 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java)
-356 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
-357 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
-358 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
-359 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
-360 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
-361 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
-362 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
-363 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
-364 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
-365 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
-366 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
-367 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
-368 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
-369 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
-370 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java)
-371 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
-372 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java)
-373 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
-374 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
-375 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
-376 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java)
-377 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
-378 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
-379 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
-380 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
-381 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
-382 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
-383 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
-384 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
-385 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java)
-386 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java)
-387 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
-388 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
-389 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java)
-390 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
-391 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
-392 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
-393 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
-394 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
-395 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
-396 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
-397 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
-398 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
-399 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
-400 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
-401 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
-402 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
-403 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java)
-404 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
-405 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
-406 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
-407 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
-408 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java)
-409 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
-410 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
-411 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
-412 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
-413 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
-414 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java)
-415 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
-416 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
-417 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
-418 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java)
-419 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
-420 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java)
-421 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
-422 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
-423 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
-424 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
-425 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
-426 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
-427 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
-428 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java)
-429 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
-430 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
-431 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
-432 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java)
-433 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
-434 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
-435 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
-436 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java)
-437 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
-438 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
-439 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
-440 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
-441 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
-442 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
-443 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
-444 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
-445 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
-446 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
-447 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java)
-448 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
-449 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
-450 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
-451 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
-452 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
-453 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java)
-454 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
-455 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
-456 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java)
-457 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
-458 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
-459 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
-460 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
-461 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
-462 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
-463 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
-464 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
-465 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
-466 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java)
-467 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
-468 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
-469 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java)
-470 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
-471 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
-472 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
-473 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
-474 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
-475 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java)
-476 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
-477 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
-478 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
-479 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java)
-480 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java)
-481 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
-482 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
-483 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
-484 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
-485 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java)
-486 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
-487 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java)
-488 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
-489 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
-490 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
-491 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
-492 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
-493 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
-494 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
-495 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
-496 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
-497 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java)
-498 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
-499 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
-500 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
-501 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
-502 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
-503 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java)
-504 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
-505 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
-506 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
-507 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
-508 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java)
-509 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
-510 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
-511 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
-512 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
-513 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
-514 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java)
-515 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java)
-516 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
-517 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java)
-518 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
-519 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
-520 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
-521 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
-522 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
-523 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java)
-524 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
-525 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
-526 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
-527 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
-528 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java)
-529 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java)
-530 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
-531 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
-532 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
-533 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
-534 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
-535 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
-536 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
-537 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
-538 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
-539 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
-540 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
-541 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
-542 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
-543 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
-544 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
-545 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
-546 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
-547 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java)
-548 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
-549 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java)
-550 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
-551 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
-552 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
-553 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
-554 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java)
-555 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
-556 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
-557 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
+113 | [Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java)
+114 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java)
+115 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
+116 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java)
+117 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
+118 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
+119 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
+120 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
+121 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
+122 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
+123 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
+124 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java)
+125 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
+126 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
+127 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
+128 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
+129 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
+130 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
+131 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
+132 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
+133 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java)
+134 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
+135 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
+136 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
+137 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
+138 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
+139 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java)
+140 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
+141 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
+142 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
+143 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
+144 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
+145 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
+146 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
+147 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java)
+148 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
+149 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
+150 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java)
+151 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
+152 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
+153 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
+154 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java)
+155 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java)
+156 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
+157 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
+158 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
+159 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
+160 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java)
+161 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
+162 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
+163 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
+164 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
+165 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java)
+166 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
+167 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java)
+168 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java)
+169 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
+170 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
+171 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
+172 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java)
+173 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
+174 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java)
+175 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
+176 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
+177 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
+178 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
+179 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
+180 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
+181 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
+182 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
+183 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java)
+184 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
+185 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java)
+186 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java)
+187 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
+188 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
+189 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java)
+190 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java)
+191 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java)
+192 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
+193 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
+194 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java)
+195 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java)
+196 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
+197 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
+198 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java)
+199 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
+200 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java)
+201 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
+202 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
+203 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
+204 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
+205 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
+206 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
+207 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
+208 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
+209 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
+210 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
+211 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
+212 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
+213 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java)
+214 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
+215 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
+216 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
+217 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
+218 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
+219 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
+220 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
+221 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
+222 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
+223 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
+224 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
+225 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
+226 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
+227 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
+228 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
+229 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
+230 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
+231 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java)
+232 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
+233 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java)
+234 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
+235 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
+236 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
+237 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
+238 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
+239 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
+240 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
+241 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
+242 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
+243 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java)
+244 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
+245 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
+246 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java)
+247 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
+248 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
+249 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java)
+250 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java)
+251 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java)
+252 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
+253 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
+254 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
+255 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java)
+256 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
+257 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
+258 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
+259 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
+260 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
+261 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
+262 | [Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java)
+263 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
+264 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
+265 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
+266 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
+267 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
+268 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
+269 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
+270 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
+271 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
+272 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
+273 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
+274 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
+275 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
+276 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java)
+277 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
+278 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
+279 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
+280 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
+281 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
+282 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
+283 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
+284 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java)
+285 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
+286 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
+287 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
+288 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
+289 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java)
+290 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
+291 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
+292 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
+293 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java)
+294 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
+295 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java)
+296 | [Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java)
+297 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
+298 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java)
+299 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
+300 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
+301 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
+302 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java)
+303 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java)
+304 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
+305 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
+306 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
+307 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java)
+308 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
+309 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
+310 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
+311 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
+312 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java)
+313 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
+314 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
+315 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
+316 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java)
+317 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
+318 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
+319 | [Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java)
+320 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
+321 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
+322 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
+323 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
+324 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java)
+325 | [Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
+326 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
+327 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java)
+328 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java)
+329 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
+330 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java)
+331 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java)
+332 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java)
+333 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java)
+334 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
+335 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
+336 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
+337 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
+338 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java)
+339 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
+340 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java)
+341 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
+342 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java)
+343 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java)
+344 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
+345 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java)
+346 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
+347 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java)
+348 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
+349 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
+350 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
+351 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
+352 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
+353 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
+354 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java)
+355 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
+356 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
+357 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java)
+358 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java)
+359 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
+360 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
+361 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
+362 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
+363 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
+364 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
+365 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
+366 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
+367 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
+368 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
+369 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
+370 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
+371 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
+372 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
+373 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java)
+374 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
+375 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java)
+376 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
+377 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
+378 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
+379 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java)
+380 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
+381 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
+382 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
+383 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
+384 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
+385 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
+386 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
+387 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
+388 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java)
+389 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java)
+390 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
+391 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
+392 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java)
+393 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
+394 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
+395 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
+396 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
+397 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
+398 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
+399 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
+400 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
+401 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
+402 | [Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java)
+403 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
+404 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
+405 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
+406 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
+407 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java)
+408 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
+409 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
+410 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
+411 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
+412 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java)
+413 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
+414 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
+415 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
+416 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
+417 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
+418 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java)
+419 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
+420 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
+421 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
+422 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java)
+423 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
+424 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java)
+425 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
+426 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
+427 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
+428 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
+429 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
+430 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
+431 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
+432 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java)
+433 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
+434 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
+435 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
+436 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java)
+437 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
+438 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
+439 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
+440 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java)
+441 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
+442 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
+443 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
+444 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
+445 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
+446 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
+447 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
+448 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
+449 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
+450 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
+451 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java)
+452 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
+453 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
+454 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
+455 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
+456 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
+457 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java)
+458 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
+459 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
+460 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java)
+461 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
+462 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
+463 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
+464 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
+465 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
+466 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
+467 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
+468 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
+469 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
+470 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java)
+471 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
+472 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
+473 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java)
+474 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
+475 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
+476 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
+477 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
+478 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
+479 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java)
+480 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
+481 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
+482 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
+483 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java)
+484 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java)
+485 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
+486 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
+487 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
+488 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
+489 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java)
+490 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
+491 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java)
+492 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
+493 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
+494 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
+495 | [Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java)
+496 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
+497 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
+498 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
+499 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
+500 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
+501 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
+502 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java)
+503 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
+504 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
+505 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
+506 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
+507 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
+508 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java)
+509 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
+510 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
+511 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
+512 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
+513 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java)
+514 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
+515 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
+516 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
+517 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
+518 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
+519 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java)
+520 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java)
+521 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
+522 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java)
+523 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
+524 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
+525 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
+526 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
+527 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
+528 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java)
+529 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
+530 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
+531 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
+532 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
+533 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java)
+534 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java)
+535 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
+536 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
+537 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
+538 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
+539 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
+540 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
+541 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
+542 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
+543 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
+544 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
+545 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
+546 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
+547 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
+548 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
+549 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
+550 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
+551 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
+552 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java)
+553 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
+554 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java)
+555 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
+556 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
+557 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
+558 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
+559 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java)
+560 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
+561 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
+562 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
diff --git a/Hard/README.md b/Hard/README.md
index 75b409d1..3ada6cad 100644
--- a/Hard/README.md
+++ b/Hard/README.md
@@ -11,87 +11,90 @@ S.no | Coding Problem
 8 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
 9 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
 10 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java)
-11 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java)
-12 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java)
-13 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java)
-14 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java)
-15 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
-16 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java)
-17 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java)
-18 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
-19 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java)
-20 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java)
-21 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
-22 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
-23 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
-24 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java)
-25 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java)
-26 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
-27 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java)
-28 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
-29 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
-30 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
-31 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
-32 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
-33 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java)
-34 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java)
-35 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
-36 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
-37 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
-38 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
-39 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java)
-40 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java)
-41 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java)
-42 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
-43 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
-44 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java)
-45 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java)
-46 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
-47 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
-48 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
-49 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
-50 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
-51 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java)
-52 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java)
-53 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java)
-54 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
-55 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java)
-56 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java)
-57 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
-58 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java)
-59 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
-60 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
-61 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
-62 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
-63 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
-64 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
-65 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java)
-66 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
-67 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
-68 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java)
-69 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java)
-70 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
-71 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java)
-72 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
-73 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
-74 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
-75 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
-76 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
-77 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
-78 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
-79 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
-80 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
-81 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java)
-82 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
-83 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java)
-84 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
-85 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
-86 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
-87 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java)
-88 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
-89 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
-90 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
-91 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java)
-92 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java)
-93 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
-94 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
+11 | [Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java)
+12 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java)
+13 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java)
+14 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java)
+15 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java)
+16 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
+17 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java)
+18 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java)
+19 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
+20 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java)
+21 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java)
+22 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
+23 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
+24 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
+25 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java)
+26 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java)
+27 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
+28 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java)
+29 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
+30 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
+31 | [IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java)
+32 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
+33 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
+34 | [Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java)
+35 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
+36 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java)
+37 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java)
+38 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
+39 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
+40 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
+41 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
+42 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java)
+43 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java)
+44 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java)
+45 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
+46 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
+47 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java)
+48 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java)
+49 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
+50 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
+51 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
+52 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
+53 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
+54 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java)
+55 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java)
+56 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java)
+57 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
+58 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java)
+59 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java)
+60 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
+61 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java)
+62 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
+63 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
+64 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
+65 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
+66 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
+67 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
+68 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java)
+69 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
+70 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
+71 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java)
+72 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java)
+73 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
+74 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java)
+75 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
+76 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
+77 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
+78 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
+79 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
+80 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
+81 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
+82 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
+83 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
+84 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java)
+85 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
+86 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java)
+87 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
+88 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
+89 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
+90 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java)
+91 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
+92 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
+93 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
+94 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java)
+95 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java)
+96 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
+97 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
diff --git a/Medium/README.md b/Medium/README.md
index afdf245d..cea9747e 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -229,513 +229,517 @@ S.no | Coding Problem
 226 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
 227 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
 228 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java)
-229 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
-230 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
-231 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java)
-232 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
-233 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
-234 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
-235 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
-236 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
-237 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
-238 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
-239 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
-240 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
-241 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
-242 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
-243 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
-244 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java)
-245 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
-246 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java)
-247 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
-248 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
-249 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
-250 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
-251 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
-252 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
-253 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
-254 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
-255 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
-256 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
-257 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
-258 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
-259 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
-260 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
-261 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
-262 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
-263 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java)
-264 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java)
-265 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
-266 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
-267 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
-268 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java)
-269 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
-270 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
-271 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
-272 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
-273 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
-274 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
-275 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java)
-276 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
-277 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
-278 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
-279 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
-280 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
-281 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
-282 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java)
-283 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
-284 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
-285 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
-286 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
-287 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java)
-288 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java)
-289 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java)
-290 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
-291 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java)
-292 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java)
-293 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
-294 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
-295 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
-296 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
-297 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
-298 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
-299 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
-300 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
-301 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java)
-302 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
-303 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
-304 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
-305 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java)
-306 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
-307 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
-308 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
-309 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
-310 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java)
-311 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
-312 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
-313 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java)
-314 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java)
-315 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
-316 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
-317 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
-318 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
-319 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
-320 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
-321 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
-322 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
-323 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java)
-324 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
-325 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
-326 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java)
-327 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
-328 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
-329 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
-330 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
-331 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java)
-332 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
-333 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
-334 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
-335 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java)
-336 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
-337 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java)
-338 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
-339 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
-340 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
-341 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java)
-342 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
-343 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
-344 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
-345 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
-346 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
-347 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java)
-348 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java)
-349 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
-350 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
-351 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
-352 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
-353 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java)
-354 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
-355 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java)
-356 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
-357 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java)
-358 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java)
-359 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
-360 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java)
-361 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
-362 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java)
-363 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
-364 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
-365 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java)
-366 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
-367 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
-368 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
-369 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
-370 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
-371 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java)
-372 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
-373 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
-374 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java)
-375 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java)
-376 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java)
-377 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java)
-378 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java)
-379 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java)
-380 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
-381 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
-382 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
-383 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java)
-384 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
-385 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java)
-386 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java)
-387 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
-388 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java)
-389 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
-390 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java)
-391 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java)
-392 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java)
-393 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java)
-394 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java)
-395 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java)
-396 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
-397 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
-398 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
-399 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
-400 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
-401 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
-402 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
-403 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
-404 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
-405 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java)
-406 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java)
-407 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java)
-408 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
-409 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
-410 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
-411 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java)
-412 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
-413 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java)
-414 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
-415 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java)
-416 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java)
-417 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
-418 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
-419 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java)
-420 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
-421 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
-422 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java)
-423 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java)
-424 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
-425 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java)
-426 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
-427 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
-428 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
-429 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java)
-430 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java)
-431 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
-432 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java)
-433 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
-434 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
-435 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
-436 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
-437 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
-438 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
-439 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java)
-440 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
-441 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
-442 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java)
-443 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
-444 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java)
-445 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java)
-446 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java)
-447 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java)
-448 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
-449 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
-450 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java)
-451 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java)
-452 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
-453 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
-454 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
-455 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
-456 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java)
-457 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java)
-458 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
-459 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
-460 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
-461 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
-462 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
-463 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
-464 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java)
-465 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
-466 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java)
-467 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
-468 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java)
-469 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
-470 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java)
-471 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
-472 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
-473 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
-474 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java)
-475 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java)
-476 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
-477 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java)
-478 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
-479 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
-480 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
-481 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
-482 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java)
-483 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java)
-484 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java)
-485 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java)
-486 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
-487 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
-488 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
-489 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
-490 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java)
-491 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java)
-492 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
-493 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
-494 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
-495 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java)
-496 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
-497 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
-498 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
-499 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
-500 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java)
-501 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java)
-502 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
-503 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java)
-504 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
-505 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
-506 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
-507 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java)
-508 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java)
-509 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java)
-510 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
-511 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
-512 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
-513 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
-514 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java)
-515 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
-516 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
-517 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
-518 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
-519 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
-520 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
-521 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
-522 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
-523 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
-524 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
-525 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
-526 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
-527 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
-528 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java)
-529 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
-530 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java)
-531 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
-532 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
-533 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
-534 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
-535 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
-536 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
-537 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
-538 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java)
-539 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
-540 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
-541 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java)
-542 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java)
-543 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
-544 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
-545 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
-546 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
-547 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
-548 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
-549 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
-550 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
-551 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
-552 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
-553 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
-554 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java)
-555 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java)
-556 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
-557 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java)
-558 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
-559 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
-560 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
-561 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
-562 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
-563 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java)
-564 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
-565 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
-566 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
-567 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
-568 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java)
-569 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
-570 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
-571 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
-572 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java)
-573 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
-574 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
-575 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
-576 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java)
-577 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java)
-578 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
-579 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
-580 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java)
-581 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
-582 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
-583 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java)
-584 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
-585 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
-586 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
-587 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java)
-588 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
-589 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java)
-590 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java)
-591 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
-592 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
-593 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
-594 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
-595 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
-596 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
-597 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
-598 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
-599 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java)
-600 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
-601 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java)
-602 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
-603 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
-604 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
-605 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
-606 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java)
-607 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
-608 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
-609 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
-610 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
-611 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
-612 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
-613 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
-614 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java)
-615 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
-616 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
-617 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
-618 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
-619 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
-620 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
-621 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java)
-622 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
-623 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
-624 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
-625 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java)
-626 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
-627 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
-628 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
-629 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
-630 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java)
-631 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
-632 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
-633 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
-634 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
-635 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
-636 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
-637 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
-638 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java)
-639 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
-640 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java)
-641 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
-642 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
-643 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
-644 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
-645 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
-646 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
-647 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java)
-648 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
-649 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
-650 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java)
-651 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
-652 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java)
-653 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
-654 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
-655 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
-656 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
-657 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
-658 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java)
-659 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
-660 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java)
-661 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java)
-662 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java)
-663 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java)
-664 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java)
-665 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
-666 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
-667 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
-668 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java)
-669 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
-670 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
-671 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
-672 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java)
-673 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
-674 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
-675 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java)
-676 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java)
-677 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
-678 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java)
-679 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java)
-680 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
-681 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
-682 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
-683 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
-684 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
-685 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java)
-686 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
-687 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
-688 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
-689 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
-690 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
-691 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java)
-692 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
-693 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
-694 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
-695 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
-696 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
-697 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java)
-698 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
-699 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
-700 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
-701 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java)
-702 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java)
-703 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
-704 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
-705 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java)
-706 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java)
-707 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
-708 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java)
-709 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java)
-710 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
-711 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
-712 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
-713 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
-714 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
-715 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
-716 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
-717 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
-718 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
-719 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
-720 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
-721 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
-722 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
-723 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
-724 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
-725 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
-726 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java)
-727 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
-728 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
-729 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java)
-730 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
-731 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
-732 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java)
-733 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
-734 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
-735 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
-736 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java)
-737 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
-738 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
+229 | [Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java)
+230 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
+231 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
+232 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java)
+233 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
+234 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
+235 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
+236 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
+237 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
+238 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
+239 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
+240 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
+241 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
+242 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
+243 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
+244 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
+245 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java)
+246 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
+247 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java)
+248 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
+249 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
+250 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
+251 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
+252 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
+253 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
+254 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
+255 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
+256 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
+257 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
+258 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
+259 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
+260 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
+261 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
+262 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
+263 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
+264 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java)
+265 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java)
+266 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
+267 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
+268 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
+269 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java)
+270 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
+271 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
+272 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
+273 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
+274 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
+275 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
+276 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java)
+277 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
+278 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
+279 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
+280 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
+281 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
+282 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
+283 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java)
+284 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
+285 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
+286 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
+287 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
+288 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java)
+289 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java)
+290 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java)
+291 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
+292 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java)
+293 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java)
+294 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
+295 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
+296 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
+297 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
+298 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
+299 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
+300 | [Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java)
+301 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
+302 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
+303 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java)
+304 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
+305 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
+306 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
+307 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java)
+308 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
+309 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
+310 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
+311 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
+312 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java)
+313 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
+314 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
+315 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java)
+316 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java)
+317 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
+318 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
+319 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
+320 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
+321 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
+322 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
+323 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
+324 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
+325 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java)
+326 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
+327 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
+328 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java)
+329 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
+330 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
+331 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
+332 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
+333 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java)
+334 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
+335 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
+336 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+337 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java)
+338 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
+339 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java)
+340 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
+341 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
+342 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
+343 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java)
+344 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
+345 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
+346 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
+347 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
+348 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
+349 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java)
+350 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java)
+351 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
+352 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
+353 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
+354 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
+355 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java)
+356 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
+357 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java)
+358 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
+359 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java)
+360 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java)
+361 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
+362 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java)
+363 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
+364 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java)
+365 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
+366 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
+367 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java)
+368 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
+369 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
+370 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
+371 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
+372 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
+373 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java)
+374 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
+375 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
+376 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java)
+377 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java)
+378 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java)
+379 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java)
+380 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java)
+381 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java)
+382 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
+383 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
+384 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
+385 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java)
+386 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
+387 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java)
+388 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java)
+389 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
+390 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java)
+391 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
+392 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java)
+393 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java)
+394 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java)
+395 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java)
+396 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java)
+397 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java)
+398 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java)
+399 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
+400 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
+401 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
+402 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
+403 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
+404 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
+405 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
+406 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
+407 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
+408 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java)
+409 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java)
+410 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java)
+411 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
+412 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
+413 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
+414 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java)
+415 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
+416 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java)
+417 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
+418 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java)
+419 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java)
+420 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
+421 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
+422 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java)
+423 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
+424 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
+425 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java)
+426 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java)
+427 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
+428 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java)
+429 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
+430 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
+431 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
+432 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java)
+433 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java)
+434 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
+435 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java)
+436 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
+437 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
+438 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
+439 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
+440 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
+441 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
+442 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java)
+443 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
+444 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
+445 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java)
+446 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
+447 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java)
+448 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java)
+449 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java)
+450 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java)
+451 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
+452 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
+453 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java)
+454 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java)
+455 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
+456 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
+457 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
+458 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
+459 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java)
+460 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java)
+461 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
+462 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
+463 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
+464 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
+465 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
+466 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
+467 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java)
+468 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
+469 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java)
+470 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
+471 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java)
+472 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
+473 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java)
+474 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
+475 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
+476 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
+477 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java)
+478 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java)
+479 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
+480 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java)
+481 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
+482 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
+483 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
+484 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
+485 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java)
+486 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java)
+487 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java)
+488 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java)
+489 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
+490 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
+491 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
+492 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
+493 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java)
+494 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java)
+495 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
+496 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
+497 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
+498 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java)
+499 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
+500 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
+501 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
+502 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
+503 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java)
+504 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java)
+505 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
+506 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java)
+507 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
+508 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
+509 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
+510 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java)
+511 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java)
+512 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java)
+513 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
+514 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
+515 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
+516 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
+517 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java)
+518 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
+519 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
+520 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
+521 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
+522 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
+523 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
+524 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
+525 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
+526 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
+527 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
+528 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
+529 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
+530 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
+531 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java)
+532 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
+533 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java)
+534 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
+535 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
+536 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
+537 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
+538 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
+539 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
+540 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
+541 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java)
+542 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
+543 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
+544 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java)
+545 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java)
+546 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
+547 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
+548 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
+549 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
+550 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
+551 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
+552 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
+553 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
+554 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
+555 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
+556 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
+557 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java)
+558 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java)
+559 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
+560 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java)
+561 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
+562 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
+563 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
+564 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
+565 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
+566 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java)
+567 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
+568 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
+569 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
+570 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
+571 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java)
+572 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
+573 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
+574 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
+575 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java)
+576 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
+577 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
+578 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
+579 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java)
+580 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java)
+581 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
+582 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
+583 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java)
+584 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
+585 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
+586 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java)
+587 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
+588 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
+589 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
+590 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java)
+591 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
+592 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java)
+593 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java)
+594 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
+595 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
+596 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
+597 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
+598 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
+599 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
+600 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
+601 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
+602 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java)
+603 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
+604 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java)
+605 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
+606 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
+607 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
+608 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
+609 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java)
+610 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
+611 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
+612 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
+613 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
+614 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
+615 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
+616 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
+617 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java)
+618 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
+619 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
+620 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
+621 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
+622 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
+623 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
+624 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java)
+625 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
+626 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
+627 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
+628 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java)
+629 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
+630 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
+631 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
+632 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
+633 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java)
+634 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
+635 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
+636 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
+637 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
+638 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
+639 | [Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java)
+640 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
+641 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
+642 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java)
+643 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
+644 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java)
+645 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
+646 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
+647 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
+648 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
+649 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
+650 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
+651 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java)
+652 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
+653 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
+654 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java)
+655 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
+656 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java)
+657 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
+658 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
+659 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
+660 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
+661 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
+662 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java)
+663 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
+664 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java)
+665 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java)
+666 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java)
+667 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java)
+668 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java)
+669 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
+670 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
+671 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
+672 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java)
+673 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
+674 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
+675 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
+676 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java)
+677 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
+678 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
+679 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java)
+680 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java)
+681 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
+682 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java)
+683 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java)
+684 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
+685 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
+686 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
+687 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
+688 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
+689 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java)
+690 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
+691 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
+692 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
+693 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
+694 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
+695 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java)
+696 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
+697 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
+698 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
+699 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
+700 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
+701 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java)
+702 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
+703 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
+704 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
+705 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java)
+706 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java)
+707 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
+708 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
+709 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java)
+710 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java)
+711 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
+712 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java)
+713 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java)
+714 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
+715 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
+716 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
+717 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
+718 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
+719 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
+720 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
+721 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
+722 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
+723 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
+724 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
+725 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
+726 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
+727 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
+728 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
+729 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
+730 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java)
+731 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
+732 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
+733 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java)
+734 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
+735 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
+736 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java)
+737 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
+738 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
+739 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
+740 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java)
+741 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
+742 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)

From 4897731a79532937c7eb2b7dfdd580fc68330387 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 13 Mar 2023 09:39:10 -0700
Subject: [PATCH 1577/2175] Added Rearrange Array to Maximize Prefix Score.java

---
 .../Rearrange Array to Maximize Prefix Score.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Rearrange Array to Maximize Prefix Score.java

diff --git a/Medium/Rearrange Array to Maximize Prefix Score.java b/Medium/Rearrange Array to Maximize Prefix Score.java
new file mode 100644
index 00000000..6f52eda8
--- /dev/null
+++ b/Medium/Rearrange Array to Maximize Prefix Score.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int maxScore(int[] nums) {
+        Arrays.sort(nums);
+        long currPrefixSum = 0;
+        int prefixScore = 0;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            currPrefixSum += nums[i];
+            if (currPrefixSum <= 0) {
+                break;
+            }
+            prefixScore++;
+        }
+        return prefixScore;
+    }
+}

From 463b06fa93ad0b6830fc0f3f1953109d3318cc08 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 Mar 2023 17:13:53 -0700
Subject: [PATCH 1578/2175] Update Sum Root to Leaf Numbers.java

---
 Medium/Sum Root to Leaf Numbers.java | 41 ++++++++++++++++------------
 1 file changed, 24 insertions(+), 17 deletions(-)

diff --git a/Medium/Sum Root to Leaf Numbers.java b/Medium/Sum Root to Leaf Numbers.java
index 63179830..0cad0868 100644
--- a/Medium/Sum Root to Leaf Numbers.java	
+++ b/Medium/Sum Root to Leaf Numbers.java	
@@ -14,22 +14,29 @@
  * }
  */
 class Solution {
-  public int sumNumbers(TreeNode root) {
-    int[] sum = {0};
-    helper(root, 0, sum);
-    return sum[0];
-  }
-  
-  private void helper(TreeNode root, int currValue, int[] sum) {
-    if (root == null) {
-      return;
+    public int sumNumbers(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        Queue<NodeSumPair> queue = new LinkedList<>();
+        queue.add(new NodeSumPair(root, 0));
+        int totalSum = 0;
+        while (!queue.isEmpty()) {
+            NodeSumPair removed = queue.remove();
+            TreeNode node = removed.node;
+            int currSum = removed.sum * 10 + node.val;
+            if (node.left == null && node.right == null) {
+                totalSum += currSum;
+            }
+            if (node.left != null) {
+                queue.add(new NodeSumPair(node.left, currSum));
+            }
+            if (node.right != null) {
+                queue.add(new NodeSumPair(node.right, currSum));
+            }
+        }
+        return totalSum;
     }
-    currValue = currValue * 10 + root.val;
-    if (root.left == null && root.right == null) {
-      sum[0] += currValue;
-      return;
-    }
-    helper(root.left, currValue, sum);
-    helper(root.right, currValue, sum);
-  }
+    
+    private static record NodeSumPair(TreeNode node, int sum) {}
 }

From 6d9400d4e209d87775410b4180f8f13337f0a150 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 15 Mar 2023 07:15:25 -0700
Subject: [PATCH 1579/2175] Updated Check Completeness of a Binary Tree

---
 .../Check Completeness of a Binary Tree.java  | 33 ++++++++++---------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/Medium/Check Completeness of a Binary Tree.java b/Medium/Check Completeness of a Binary Tree.java
index 30ee5adb..2d0c94f0 100644
--- a/Medium/Check Completeness of a Binary Tree.java	
+++ b/Medium/Check Completeness of a Binary Tree.java	
@@ -14,22 +14,23 @@
  * }
  */
 class Solution {
-  public boolean isCompleteTree(TreeNode root) {
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    boolean end = false;
-    while (!queue.isEmpty()) {
-      TreeNode removed = queue.poll();
-      if (removed == null) {
-        end = true;
-      } else {
-        if (end) {
-          return false;
+    public boolean isCompleteTree(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        boolean isEnd = false;
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            TreeNode removed = queue.remove();
+            if (removed == null) {
+                isEnd = true;
+            } 
+            if (removed != null) {
+                if (isEnd) {
+                    return false;
+                }
+                queue.add(removed.left);
+                queue.add(removed.right);
+            }
         }
-        queue.add(removed.left);
-        queue.add(removed.right);
-      }
+        return true;
     }
-    return true;
-  }
 }

From b01c0ce5201c34b5c7d1d807be6ab26a9d23c4cc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 15 Mar 2023 07:29:10 -0700
Subject: [PATCH 1580/2175] Updated Clone Binary Tree With Random Pointer

---
 ...Clone Binary Tree With Random Pointer.java | 69 +++++++++----------
 1 file changed, 34 insertions(+), 35 deletions(-)

diff --git a/Medium/Clone Binary Tree With Random Pointer.java b/Medium/Clone Binary Tree With Random Pointer.java
index 323b1b6e..cf43c71a 100644
--- a/Medium/Clone Binary Tree With Random Pointer.java	
+++ b/Medium/Clone Binary Tree With Random Pointer.java	
@@ -17,44 +17,43 @@
  */
 
 class Solution {
-  public NodeCopy copyRandomBinaryTree(Node root) {
-    if (root == null) {
-      return null;
-    }
-    Queue<Node> queue = new LinkedList<>();
-    Map<Node, NodeCopy> map = new HashMap<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        Node removed = queue.remove();
-        map.put(removed, new NodeCopy(removed.val));
-        if (removed.left != null) {
-          queue.add(removed.left);
-        }
-        if (removed.right != null) {
-          queue.add(removed.right);
+    public NodeCopy copyRandomBinaryTree(Node root) {
+        if (root == null) {
+            return null;
         }
-      }
+        Map<Node, NodeCopy> map = new HashMap<>();
+        copyOnlyNode(root, map);
+        copyNodePointers(root, map);
+        return map.get(root);
     }
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        Node removed = queue.remove();
-        if (removed.left != null) {
-          queue.add(removed.left);
-          map.get(removed).left = map.get(removed.left);
+    
+    private void copyNodePointers(Node root, Map<Node, NodeCopy> map) {
+        Queue<Node> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            Node removed = queue.remove();
+            NodeCopy copied = map.get(removed);
+            if (removed.left != null) {
+                queue.add(removed.left);
+                copied.left = map.get(removed.left);
+            }
+            if (removed.right != null) {
+                queue.add(removed.right);
+                copied.right = map.get(removed.right);
+            }
+            if (removed.random != null) {
+                copied.random = map.get(removed.random);
+            }
         }
-        if (removed.right != null) {
-          queue.add(removed.right);
-          map.get(removed).right = map.get(removed.right);
-        }
-        if (removed.random != null) {
-          map.get(removed).random = map.get(removed.random);
+    }
+    
+    private void copyOnlyNode(Node root, Map<Node, NodeCopy> map) {
+        if (root == null) {
+            return;
         }
-      }
+        NodeCopy copiedNode = new NodeCopy(root.val);
+        map.put(root, copiedNode);
+        copyOnlyNode(root.left, map);
+        copyOnlyNode(root.right, map);
     }
-    return map.get(root);
-  }
 }

From a0c9a40f466a65624dc80dc3e1b38d2c86444587 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 16 Mar 2023 19:56:58 -0700
Subject: [PATCH 1581/2175] Updated Implement Trie (Prefix Tree)

---
 Medium/Implement Trie (Prefix Tree).java | 101 ++++++++++++-----------
 1 file changed, 53 insertions(+), 48 deletions(-)

diff --git a/Medium/Implement Trie (Prefix Tree).java b/Medium/Implement Trie (Prefix Tree).java
index 8df3049a..353634fd 100644
--- a/Medium/Implement Trie (Prefix Tree).java	
+++ b/Medium/Implement Trie (Prefix Tree).java	
@@ -1,56 +1,61 @@
+import java.util.Optional;
+
 class Trie {
-  
-  private TrieNode root;
-  
-  public Trie() {
-    this.root = new TrieNode();
-  }
-
-  public void insert(String word) {
-    TrieNode curr = root;
-    for (char c : word.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        curr.children.put(c, new TrieNode());
-      }
-      curr = curr.children.get(c);
+
+    private final TrieNode root;
+
+    public Trie() {
+        root = new TrieNode();
     }
-    curr.isWord = true;
-  }
-
-  public boolean search(String word) {
-    TrieNode searchNode = searchHelper(word);
-    return searchNode != null && searchNode.isWord;
-  }
-
-  public boolean startsWith(String prefix) {
-    return searchHelper(prefix) != null;
-  }
-  
-  private TrieNode searchHelper(String s) {
-    TrieNode curr = root;
-    for (char c : s.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        return null;
-      }
-      curr = curr.children.get(c);
+
+    public void insert(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                curr.children.put(c, new TrieNode());
+            }
+            curr = curr.children.get(c);
+        }
+        curr.isWord = true;
+    }
+
+    public boolean search(String word) {
+        Optional<TrieNode> node = searchHelper(word);
+        return node.isPresent() && node.get().isWord;
+    }
+
+    public boolean startsWith(String prefix) {
+        Optional<TrieNode> node = searchHelper(prefix);
+        return node.isPresent();
     }
-    return curr;
-  }
-  
-  private class TrieNode {
-    Map<Character, TrieNode> children;
-    boolean isWord;
     
-    public TrieNode() {
-      this.children = new HashMap<>();
+    public Optional<TrieNode> searchHelper(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                return Optional.empty();
+            }
+            curr = curr.children.get(c);
+        }
+        return Optional.of(curr);
+    }
+
+    private static class TrieNode {
+        
+        private final Map<Character, TrieNode> children;
+        private boolean isWord;
+
+        private TrieNode() {
+            this.children = new HashMap<>();
+            this.isWord = false;
+        }
     }
-  }
 }
 
 /**
-* Your Trie object will be instantiated and called as such:
-* Trie obj = new Trie();
-* obj.insert(word);
-* boolean param_2 = obj.search(word);
-* boolean param_3 = obj.startsWith(prefix);
-*/
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * boolean param_2 = obj.search(word);
+ * boolean param_3 = obj.startsWith(prefix);
+ */

From 9a1d2396465c3dc985c3859bb09f17bc8113aa48 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 18 Mar 2023 07:51:51 -0700
Subject: [PATCH 1582/2175] Updated Design Browser History

---
 Medium/Design Browser History.java | 50 +++++++++++++++---------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/Medium/Design Browser History.java b/Medium/Design Browser History.java
index 8aa9f71f..63799e9d 100644
--- a/Medium/Design Browser History.java	
+++ b/Medium/Design Browser History.java	
@@ -1,32 +1,32 @@
 class BrowserHistory {
+    
+    private final Stack<String> history;
+    private final Stack<String> future;
 
-  private Stack<String> history;
-  private Stack<String> future;
-
-  public BrowserHistory(String homepage) {
-    this.history = new Stack<>();
-    this.history.push(homepage);
-    this.future = new Stack<>();
-  }
-
-  public void visit(String url) {
-    this.future.removeAllElements();
-    this.history.push(url);
-  }
-
-  public String back(int steps) {
-    while (steps-- > 0 && this.history.size() > 1) {
-      this.future.push(this.history.pop());
+    public BrowserHistory(String homepage) {
+        this.history = new Stack<>();
+        this.future = new Stack<>();
+        this.history.push(homepage);
     }
-    return this.history.peek();
-  }
-
-  public String forward(int steps) {
-    while (steps-- > 0 && !this.future.isEmpty()) {
-      this.history.push(this.future.pop());
+    
+    public void visit(String url) {
+        future.removeAllElements();
+        history.push(url);
+    }
+    
+    public String back(int steps) {
+        while (steps-- > 0 && history.size() > 1) {
+            future.push(history.pop());
+        }
+        return history.peek();
+    }
+    
+    public String forward(int steps) {
+        while (steps-- > 0 && !future.isEmpty()) {
+            history.push(future.pop());
+        }
+        return history.peek();
     }
-    return this.history.peek();
-  }
 }
 
 /**

From f3c457c2327a18ae71d84d0f21e14ab2aa2f13b0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 18 Mar 2023 18:16:35 -0700
Subject: [PATCH 1583/2175] Updated Design Add and Search Words Data Structure

---
 ...n Add and Search Words Data Structure.java | 87 +++++++++----------
 1 file changed, 43 insertions(+), 44 deletions(-)

diff --git a/Medium/Design Add and Search Words Data Structure.java b/Medium/Design Add and Search Words Data Structure.java
index 45fc78fd..17814eb0 100644
--- a/Medium/Design Add and Search Words Data Structure.java	
+++ b/Medium/Design Add and Search Words Data Structure.java	
@@ -1,54 +1,53 @@
 class WordDictionary {
-  
-  private Node root;
-  
-  public WordDictionary() {
-    this.root = new Node();
-  }
-
-  public void addWord(String word) {
-    Node curr = root;
-    for (char c : word.toCharArray()) {
-      if (curr.children[c - 'a'] == null) {
-        curr.children[c - 'a'] = new Node();
-      }
-      curr = curr.children[c - 'a'];
+
+    private final TrieNode root;
+
+    public WordDictionary() {
+        this.root = new TrieNode();
     }
-    curr.isWord = true;
-  }
-
-  public boolean search(String word) {
-    Node curr = root;
-    return searchHelper(word, 0, curr);
-  }
-  
-  private boolean searchHelper(String word, int idx, Node curr) {
-    if (idx == word.length()) {
-      return curr.isWord;
+
+    public void addWord(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                curr.children.put(c, new TrieNode());
+            }
+            curr = curr.children.get(c);
+        }
+        curr.isWord = true;
     }
-    if (word.charAt(idx) != '.' && curr.children[word.charAt(idx) - 'a'] == null) {
-      return false;
+
+    public boolean search(String word) {
+        return searchHelper(word, 0, root);
     }
-    if (word.charAt(idx) == '.') {
-      for (Node child : curr.children) {
-        if (child != null && searchHelper(word, idx + 1, child)) {
-          return true;
+
+    private boolean searchHelper(String word, int idx, TrieNode node) {
+        if (idx == word.length()) {
+            return node.isWord;
         }
-      }
-      return false;
+        if (node.children.containsKey(word.charAt(idx))) {
+            return searchHelper(word, idx + 1, node.children.get(word.charAt(idx)));
+        }
+        if (word.charAt(idx) == '.') {
+            for (TrieNode child : node.children.values()) {
+                if (searchHelper(word, idx + 1, child)) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
-    return searchHelper(word, idx + 1, curr.children[word.charAt(idx) - 'a']);
-  }
-  
-  private static class Node {
-    Node[] children;
-    boolean isWord;
-    
-    public Node() {
-      this.children = new Node[26];
-      this.isWord = false;
+
+
+    static class TrieNode {
+        private final Map<Character, TrieNode> children;
+        private boolean isWord;
+
+        public TrieNode() {
+            this.children = new HashMap<>();
+            this.isWord = false;
+        }
     }
-  }
 }
 
 /**

From 46b64faeb7fff2af2a3289934efbe1e82dee295b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 19 Mar 2023 09:28:23 -0700
Subject: [PATCH 1584/2175] Added Distribute Money to Maximum Children.java

---
 Easy/Distribute Money to Maximum Children.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Distribute Money to Maximum Children.java

diff --git a/Easy/Distribute Money to Maximum Children.java b/Easy/Distribute Money to Maximum Children.java
new file mode 100644
index 00000000..06dd063f
--- /dev/null
+++ b/Easy/Distribute Money to Maximum Children.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int distMoney(int money, int children) {
+        money -= children;
+        if (money < 0) {
+            return -1;
+        }
+        if (money / 7 == children && money % 7 == 0) {
+            return children;
+        }
+        if (money / 7 == children - 1 && money % 7 == 3) {
+            return children - 2;
+        }
+        return Math.min(children - 1, money / 7);
+    }
+}

From a06b0d228c3383537c9367b3641f0115fc82e66d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 19 Mar 2023 17:26:33 -0700
Subject: [PATCH 1585/2175] Updated Can Place Flowers

---
 Easy/Can Place Flowers.java | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/Easy/Can Place Flowers.java b/Easy/Can Place Flowers.java
index c5b9df5d..eb2a21fb 100644
--- a/Easy/Can Place Flowers.java	
+++ b/Easy/Can Place Flowers.java	
@@ -1,19 +1,19 @@
 class Solution {
-  public boolean canPlaceFlowers(int[] flowerbed, int n) {
-    for (int i = 0; i < flowerbed.length && n > 0; i++) {
-      if (flowerbed[i] == 0) {
-        if (i == 0 && (flowerbed.length == 1 || flowerbed[i + 1] == 0)) {
-          flowerbed[i] = 1;
-          n--;
-        } else if (i == flowerbed.length - 1 && flowerbed[i - 1] == 0) {
-          flowerbed[i] = 1;
-          n--;
-        } else if (i + 1 < flowerbed.length && flowerbed[i + 1] == 0 && i - 1 >= 0 && flowerbed[i - 1] == 0) {
-          flowerbed[i] = 1;
-          n--;
+    public boolean canPlaceFlowers(int[] flowerbed, int n) {
+        for (int i = 0; i < flowerbed.length && n > 0; i++) {
+            if (canPlaceCheck(i, flowerbed)) {
+                flowerbed[i] = 1;
+                n--;
+            } 
         }
-      }
+        return n == 0;
+    }
+    
+    private boolean canPlaceCheck(int i, int[] flowerbed) {
+        return flowerbed[i] == 0 && (
+            (i == 0 && (i + 1 == flowerbed.length || flowerbed[i + 1] == 0)) || 
+            (i == flowerbed.length - 1 && (i - 1 == -1 || flowerbed[i - 1] == 0)) || 
+            (i != 0 && i != flowerbed.length - 1 && flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0)
+        );
     }
-    return n == 0;
-  }
 }

From 20bbc5734700a3266fae95108e90d68ee333d2ba Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 20 Mar 2023 18:15:55 -0700
Subject: [PATCH 1586/2175] Updated Number of Zero-Filled Subarrays

---
 Medium/Number of Zero-Filled Subarrays.java | 24 +++++++++++----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/Medium/Number of Zero-Filled Subarrays.java b/Medium/Number of Zero-Filled Subarrays.java
index af77e188..b7c17309 100644
--- a/Medium/Number of Zero-Filled Subarrays.java	
+++ b/Medium/Number of Zero-Filled Subarrays.java	
@@ -1,14 +1,16 @@
 class Solution {
-  public long zeroFilledSubarray(int[] nums) {
-    long count = 0;
-    long subarrayLength = 0;
-    for (int i = 0; i < nums.length; i++) {
-      if (nums[i] == 0) {
-        count += ++subarrayLength;
-      } else {
-        subarrayLength = 0;
-      }
+    public long zeroFilledSubarray(int[] nums) {
+        long subarrayCount = 0L;
+        int idx = 0;
+        while (idx < nums.length) {
+            long count = 0L;
+            while (idx < nums.length && nums[idx] == 0) {
+                idx++;
+                count++;
+            }
+            subarrayCount += (count * (count + 1)) / 2;
+            idx++;
+        }
+        return subarrayCount;
     }
-    return count;
-  }
 }

From e3ef07b08ef612eb6e846d3e7000784d4b51c382 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 21 Mar 2023 09:29:47 -0700
Subject: [PATCH 1587/2175] Updated Median of Two Sorted Arrays

---
 Hard/Median of Two Sorted Arrays.java | 53 +++++++++------------------
 1 file changed, 18 insertions(+), 35 deletions(-)

diff --git a/Hard/Median of Two Sorted Arrays.java b/Hard/Median of Two Sorted Arrays.java
index 375c07fa..33ec700b 100644
--- a/Hard/Median of Two Sorted Arrays.java	
+++ b/Hard/Median of Two Sorted Arrays.java	
@@ -1,42 +1,25 @@
 class Solution {
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
-        int n = nums1.length + nums2.length;
-        ArrayList<Integer> arr = new ArrayList<>();
-        
-        int i = 0;
-        int j = 0;
-        int k = 0;
-        int limit = (n)/2 + 1;
-        
-        while (i < nums1.length && j < nums2.length && k < limit) {
-            if (nums1[i] < nums2[j]) {
-                arr.add(nums1[i]);
-                i++;
-            }
-            else {
-                arr.add(nums2[j]);
-                j++;
-            }
-            k++;
-        }
-        
-        if (i < nums1.length) {
-            while (i < nums1.length && k < limit) {
-                arr.add(nums1[i]);
-                i++;
-                k++;
-            }
+        if (nums1.length < nums2.length) {
+            return findMedianSortedArrays(nums2, nums1);
         }
-        else {
-            while (j < nums2.length && k < limit) {
-                arr.add (nums2[j]);
-                j++;
-                k++;
+        int low = 0;
+        int high = nums2.length * 2;
+        while (low <= high) {
+            int midTwo = (low + high) / 2;
+            int midOne = nums1.length + nums2.length - midTwo;
+            double leftOne = (midOne == 0) ? Integer.MIN_VALUE : nums1[(midOne - 1) / 2];	
+            double leftTwo = (midTwo == 0) ? Integer.MIN_VALUE : nums2[(midTwo - 1) / 2];
+            double rightOne = (midOne == nums1.length * 2) ? Integer.MAX_VALUE : nums1[(midOne) / 2];
+            double rightTwo = (midTwo == nums2.length * 2) ? Integer.MAX_VALUE : nums2[(midTwo) / 2];
+            if (leftOne > rightTwo) {
+                low = midTwo + 1;
+            } else if (leftTwo > rightOne) {
+                high = midTwo - 1;
+            } else {
+                return (Math.max(leftOne, leftTwo) + Math.min(rightOne, rightTwo)) / 2;	
             }
         }
-        
-        k--;
-        
-        return n%2 == 0 ? (double) (arr.get(k - 1) + arr.get(k)) / 2.0 : (double) arr.get(k);
+        return -1;
     }
 }

From 1f2797f276f1f7ae119bf6e70d69a7baa7a94fce Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 21 Mar 2023 18:27:46 -0700
Subject: [PATCH 1588/2175] Added Minimum Score of a Path Between Two Cities

---
 ...um Score of a Path Between Two Cities.java | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Minimum Score of a Path Between Two Cities.java

diff --git a/Medium/Minimum Score of a Path Between Two Cities.java b/Medium/Minimum Score of a Path Between Two Cities.java
new file mode 100644
index 00000000..28b7ed1b
--- /dev/null
+++ b/Medium/Minimum Score of a Path Between Two Cities.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int minScore(int n, int[][] roads) {
+        Map<Integer, List<List<Integer>>> graph = new HashMap<>();
+        for (int[] road : roads) {
+            graph.computeIfAbsent(road[0], k -> new ArrayList<>())
+                .add(List.of(road[1], road[2]));
+            graph.computeIfAbsent(road[1], k -> new ArrayList<>())
+                .add(List.of(road[0], road[2]));
+        }
+        return bfs(n, graph);
+    }
+    
+    private int bfs(int n , Map<Integer, List<List<Integer>>> graph) {
+        boolean[] visited = new boolean[n + 1];
+        Queue<Integer> queue = new LinkedList<>();
+        int result = Integer.MAX_VALUE;
+        queue.add(1);
+        visited[1] = true;
+        while (!queue.isEmpty()) {
+            int node = queue.remove();
+            for (List<Integer> edge : graph.getOrDefault(node, new ArrayList<>())) {
+                result = Math.min(result, edge.get(1));
+                if (!visited[edge.get(0)]) {
+                    visited[edge.get(0)] = true;
+                    queue.add(edge.get(0));
+                }
+            }
+        }
+        return result;
+    }
+}

From f2c2a47849c1e6465dc82eaa611cbf6de07bf6f4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 23 Mar 2023 07:09:40 -0700
Subject: [PATCH 1589/2175] Added Number of Operations to Make Network
 Connected

---
 ... Operations to Make Network Connected.java | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 Medium/Number of Operations to Make Network Connected.java

diff --git a/Medium/Number of Operations to Make Network Connected.java b/Medium/Number of Operations to Make Network Connected.java
new file mode 100644
index 00000000..c44c17d8
--- /dev/null
+++ b/Medium/Number of Operations to Make Network Connected.java	
@@ -0,0 +1,36 @@
+class Solution {
+    public int makeConnected(int n, int[][] connections) {
+        if (connections.length < n - 1) {
+            return -1;
+        }
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] conn : connections) {
+            graph.computeIfAbsent(conn[0], k -> new HashSet<>()).add(conn[1]);
+            graph.computeIfAbsent(conn[1], k -> new HashSet<>()).add(conn[0]);
+        }
+        int count = 0;
+        boolean[] visited = new boolean[n];
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                bfs(graph, i, visited);
+                count++;
+            }
+        }
+        return count - 1;
+    }
+    
+    private void bfs(Map<Integer, Set<Integer>> graph, int start, boolean[] visited) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(start);
+        visited[start] = true;
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer node : graph.getOrDefault(removed, new HashSet<>())) {
+                if (!visited[node]) {
+                    visited[node] = true;
+                    queue.add(node);
+                }
+            }
+        }
+    }
+}

From d1591f889482881c72b7d4ae3ef9960b1dba015a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 23 Mar 2023 17:42:49 -0700
Subject: [PATCH 1590/2175] Update Reorder Routes to Make All Paths Lead to the
 City Zero.java

---
 ... Make All Paths Lead to the City Zero.java | 51 ++++++++++---------
 1 file changed, 26 insertions(+), 25 deletions(-)

diff --git a/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java b/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java
index 121798de..78f7e54f 100644
--- a/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java	
+++ b/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java	
@@ -1,30 +1,31 @@
 class Solution {
-  public int minReorder(int n, int[][] connections) {
-    Map<Integer, Set<Integer>> map = new HashMap<>();
-    Set<String> set = new HashSet<>();
-    for (int[] connection : connections) {
-      map.computeIfAbsent(connection[0], k -> new HashSet<>()).add(connection[1]);
-      map.computeIfAbsent(connection[1], k -> new HashSet<>()).add(connection[0]);
-      set.add(connection[0] + "->" + connection[1]);
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(0);
-    int numOfReorders = 0;
-    boolean[] visited = new boolean[n];
-    visited[0] = true;
-    while (!queue.isEmpty()) {
-      int removed = queue.remove();
-      for (int connection : map.getOrDefault(removed, new HashSet<>())) {
-        if (visited[connection]) {
-          continue;
+    public int minReorder(int n, int[][] connections) {
+        Map<Integer, List<List<Integer>>> graph = new HashMap<>();
+        for (int[] conn : connections) {
+            graph.computeIfAbsent(conn[0], k -> new ArrayList<>()).add(List.of(conn[1], 1));
+            graph.computeIfAbsent(conn[1], k -> new ArrayList<>()).add(List.of(conn[0], 0));
         }
-        visited[connection] = true;
-        if (!set.contains(connection + "->" + removed)) {
-          numOfReorders++;
+        int[] count = {0};
+        bfs(0, n, graph, count);
+        return count[0];
+    }
+    
+    private void bfs(int node, int n, Map<Integer, List<List<Integer>>> graph, int[] count) {
+        Queue<Integer> queue = new LinkedList<>();
+        boolean[] visited = new boolean[n];
+        visited[node] = true;
+        queue.add(node);
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (List<Integer> conn : graph.getOrDefault(removed, new ArrayList<>())) {
+                int neighbor = conn.get(0);
+                int direction = conn.get(1);
+                if (!visited[neighbor]) {
+                    count[0] += direction;
+                    visited[neighbor] = true;
+                    queue.add(neighbor);
+                }
+            }
         }
-        queue.add(connection);
-      }
     }
-    return numOfReorders;
-  }
 }

From ea605a4299846f3f1929e17a4c219c293cd3bf28 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 24 Mar 2023 19:27:03 -0700
Subject: [PATCH 1591/2175] Updated Count Unreachable Pairs of Nodes in an
 Undirected Graph

---
 ...Pairs of Nodes in an Undirected Graph.java | 57 +++++++++++--------
 1 file changed, 32 insertions(+), 25 deletions(-)

diff --git a/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java b/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java
index b8f9bb09..4b927bce 100644
--- a/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java	
+++ b/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java	
@@ -1,29 +1,36 @@
 class Solution {
-  public long countPairs(int n, int[][] edges) {
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    for (int[] edge : edges) {
-      graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
-      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    public long countPairs(int n, int[][] edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+            graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+        }
+        boolean[] visited = new boolean[n];
+        long unreachableNodeCount = (((long) n) * (n - 1)) / 2;
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                long reachCount = traverseHelper(i, graph, visited);
+                unreachableNodeCount -= (reachCount * (reachCount - 1)) / 2;
+            }
+        }
+        return unreachableNodeCount;
     }
-    long unreachableNodes = (((long) n) * (n - 1)) / 2;
-    boolean[] visited = new boolean[n];
-    for (int i = 0; i < n; i++) {
-      if (!visited[i]) {
-        long[] reachCount = {0};
-        dfs(graph, i, reachCount, visited);
-        unreachableNodes -= (reachCount[0] * (reachCount[0] - 1)) / 2;
-      }      
+
+    private long traverseHelper(int node, Map<Integer, Set<Integer>> graph, boolean[] visited) {
+        Queue<Integer> queue = new LinkedList<>();
+        long count = 0;
+        queue.add(node);
+        visited[node] = true;
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            count++;
+            for (Integer conn : graph.getOrDefault(removed, new HashSet<>())) {
+                if (!visited[conn]) {
+                    visited[conn] = true;
+                    queue.add(conn);
+                }
+            }
+        }
+        return count;
     }
-    return unreachableNodes;
-  }
-  
-  private void dfs(Map<Integer, List<Integer>> graph, int node, long[] reachCount, boolean[] visited) {
-    visited[node] = true;
-    reachCount[0]++;
-    for (Integer conn : graph.getOrDefault(node, new ArrayList<>())) {
-      if (!visited[conn]) {
-        dfs(graph, conn, reachCount, visited);
-      }
-    }
-  }
 }

From 01571afd10df1f1b4d1b6008d8d4024a36d20684 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Mar 2023 09:18:56 -0700
Subject: [PATCH 1592/2175] Added Longest Cycle in a Graph

---
 Hard/Longest Cycle in a Graph.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Hard/Longest Cycle in a Graph.java

diff --git a/Hard/Longest Cycle in a Graph.java b/Hard/Longest Cycle in a Graph.java
new file mode 100644
index 00000000..6405e016
--- /dev/null
+++ b/Hard/Longest Cycle in a Graph.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int longestCycle(int[] edges) {
+        int n = edges.length;
+        boolean[] visited = new boolean[n];
+        int[] result = {-1};
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                Map<Integer, Integer> map = new HashMap<>();
+                map.put(i, 1);
+                dfs(i, edges, map, visited, result);
+            }
+        }
+        return result[0];
+    }
+    
+    private void dfs(int node, int[] edges, Map<Integer, Integer> map, boolean[] visited, int[] result) {
+        visited[node] = true;
+        int neighbor = edges[node];
+        if (neighbor != -1 && !visited[neighbor]) {
+            map.put(neighbor, map.get(node) + 1);
+            dfs(neighbor, edges, map, visited, result);
+        } else if (neighbor != -1 && map.containsKey(neighbor)) {
+            result[0] = Math.max(result[0], map.get(node) - map.get(neighbor) + 1);
+        }
+    }
+}

From 8c6f7851a76308b2e3c3d34aaaa513ab3c8af150 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Mar 2023 10:43:33 -0700
Subject: [PATCH 1593/2175] Added K Items With the Maximum Sum

---
 Easy/K Items With the Maximum Sum.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/K Items With the Maximum Sum.java

diff --git a/Easy/K Items With the Maximum Sum.java b/Easy/K Items With the Maximum Sum.java
new file mode 100644
index 00000000..01d51965
--- /dev/null
+++ b/Easy/K Items With the Maximum Sum.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {
+        int sum = 0;
+        sum += Math.min(numOnes, k) * 1;
+        k -= Math.min(numOnes, k);
+        sum += Math.min(numZeros, k) * 0;
+        k -= Math.min(numZeros, k);
+        sum += Math.min(numNegOnes, k) * -1;
+        return sum;
+    }
+}

From 96e0ff49797fef67f902553c610928e8459b5e03 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 26 Mar 2023 17:40:14 -0700
Subject: [PATCH 1594/2175] Updated Minimum Path Sum

---
 Medium/Minimum Path Sum.java | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Medium/Minimum Path Sum.java b/Medium/Minimum Path Sum.java
index 2100ec3a..0565b7b0 100644
--- a/Medium/Minimum Path Sum.java	
+++ b/Medium/Minimum Path Sum.java	
@@ -1,18 +1,18 @@
 class Solution {
-  public int minPathSum(int[][] grid) {
-    int[][] dp = new int[grid.length][grid[0].length];
-    for (int i = 0; i < dp.length; i++) {
-      for (int j = 0; j < dp[i].length; j++) {
-        dp[i][j] += grid[i][j];
-        if (i > 0 && j > 0) {
-          dp[i][j] += Math.min(dp[i - 1][j], dp[i][j - 1]);
-        } else if (i > 0) {
-          dp[i][j] += dp[i - 1][j];
-        } else if (j > 0) {
-          dp[i][j] += dp[i][j - 1];
+    public int minPathSum(int[][] grid) {
+        int[][] dp = new int[grid.length][grid[0].length];
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                dp[i][j] = grid[i][j];
+                if (i > 0 && j > 0) {
+                    dp[i][j] += Math.min(dp[i - 1][j], dp[i][j - 1]);
+                } else if (i > 0) {
+                    dp[i][j] += dp[i - 1][j];
+                } else if (j > 0) {
+                    dp[i][j] += dp[i][j - 1];
+                }
+            }
         }
-      }
+        return dp[grid.length - 1][grid[0].length - 1];
     }
-    return dp[grid.length - 1][grid[0].length - 1];
-  }
 }

From a5baef0a157d3aefe256a41c495928cd2d3e2c64 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 28 Mar 2023 08:08:49 -0700
Subject: [PATCH 1595/2175] Added Minimum Cost For Tickets

---
 Medium/Minimum Cost For Tickets.java | 29 ++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Minimum Cost For Tickets.java

diff --git a/Medium/Minimum Cost For Tickets.java b/Medium/Minimum Cost For Tickets.java
new file mode 100644
index 00000000..8867660b
--- /dev/null
+++ b/Medium/Minimum Cost For Tickets.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int mincostTickets(int[] days, int[] costs) {
+        Set<Integer> daySet = new HashSet<>();
+        for (int day : days) {
+            daySet.add(day);
+        }
+        int[] dp = new int[days[days.length - 1]];
+        return helper(days[days.length - 1], daySet, costs, dp);
+    }
+    
+    private int helper(int currDay, Set<Integer> daySet, int[] costs, int[] dp) {
+        if (currDay <= 0) {
+            return 0;
+        }
+        if (dp[currDay - 1] != 0) {
+            return dp[currDay - 1];
+        }
+        int result = 0;
+        if (daySet.contains(currDay)) {
+            int one = helper(currDay - 1, daySet, costs, dp) + costs[0];
+            int seven = helper(currDay - 7, daySet, costs, dp) + costs[1];
+            int thirty = helper(currDay - 30, daySet, costs, dp) + costs[2];
+            result = Math.min(one, Math.min(seven, thirty));
+        } else {
+            result = helper(currDay - 1, daySet, costs, dp);
+        }
+        return dp[currDay - 1] = result;
+    }
+}

From b60c6d76e839dd78f8b1a0853a6ded43486a5cb7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 28 Mar 2023 18:39:07 -0700
Subject: [PATCH 1596/2175] Added Reducing Dishes

---
 Hard/Reducing Dishes.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Hard/Reducing Dishes.java

diff --git a/Hard/Reducing Dishes.java b/Hard/Reducing Dishes.java
new file mode 100644
index 00000000..2a69540e
--- /dev/null
+++ b/Hard/Reducing Dishes.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int maxSatisfaction(int[] satisfaction) {
+        Arrays.sort(satisfaction);
+        int n = satisfaction.length;
+        Integer[][] dp = new Integer[n + 1][n + 1];
+        return helper(satisfaction, 0, 1, dp);
+    }
+    
+    private int helper(int[] satisfaction, int idx, int time, Integer[][] dp) {
+        if (idx == satisfaction.length) {
+            return 0;
+        }
+        if (dp[idx][time] != null) {
+            return dp[idx][time];
+        }
+        dp[idx][time] = Math.max(satisfaction[idx] * time + helper(satisfaction, idx + 1, time + 1, dp),
+                                 helper(satisfaction, idx + 1, time, dp));
+        return dp[idx][time];
+    }
+}

From f35c580ea510cb5d4153da0631d6d3c61da25b6d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 30 Mar 2023 06:52:38 -0700
Subject: [PATCH 1597/2175] Added Scramble String

---
 Hard/Scramble String.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Hard/Scramble String.java

diff --git a/Hard/Scramble String.java b/Hard/Scramble String.java
new file mode 100644
index 00000000..ac35d39c
--- /dev/null
+++ b/Hard/Scramble String.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public boolean isScramble(String s1, String s2) {
+        int n = s1.length();
+        Boolean[][][] dp = new Boolean[n][n][n + 1];
+        return helper(s1, s2, 0, 0, n, dp);
+    }
+    
+    private boolean helper(String s1, String s2, int idxOne, int idxTwo, int n, Boolean[][][] dp) {
+        if (dp[idxOne][idxTwo][n] != null) {
+            return dp[idxOne][idxTwo][n];
+        }
+        if (n == 1) {
+            return dp[idxOne][idxTwo][n]  = s1.charAt(idxOne) == s2.charAt(idxTwo);
+        }
+        for (int l = 1; l < n; l++) {
+            if (helper(s1, s2, idxOne, idxTwo, l, dp) && helper(s1, s2, idxOne + l, idxTwo + l, n - l, dp)) {
+                return dp[idxOne][idxTwo][n] = true;
+            }
+            if (helper(s1, s2, idxOne, idxTwo + n - l, l, dp) && helper(s1, s2, idxOne + l, idxTwo, n - l, dp)) {
+                return dp[idxOne][idxTwo][n] = true;
+            }
+        }
+        return dp[idxOne][idxTwo][n] = false;
+    }
+}

From aa0b930116863355cddaa45fe226d63f7fe16021 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 30 Mar 2023 19:49:42 -0700
Subject: [PATCH 1598/2175] Added Number of Ways of Cutting a Pizza

---
 Hard/Number of Ways of Cutting a Pizza.java | 37 +++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Hard/Number of Ways of Cutting a Pizza.java

diff --git a/Hard/Number of Ways of Cutting a Pizza.java b/Hard/Number of Ways of Cutting a Pizza.java
new file mode 100644
index 00000000..a96b2064
--- /dev/null
+++ b/Hard/Number of Ways of Cutting a Pizza.java	
@@ -0,0 +1,37 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007; 
+    
+    public int ways(String[] pizza, int k) {
+        int rows = pizza.length;
+        int cols = pizza[0].length();
+        int[][] apples = new int[rows + 1][cols + 1];
+        int[][][] dp = new int[k][rows][cols];
+        for (int row = rows - 1; row >= 0; row--) {
+            for (int col = cols - 1; col >= 0; col--) {
+                apples[row][col] = (pizza[row].charAt(col) == 'A' ? 1 : 0) + apples[row + 1][col] + apples[row][col + 1] - apples[row + 1][col + 1];
+                dp[0][row][col] = apples[row][col] > 0 ? 1 : 0;
+            }
+        }
+        
+        for (int i = 1; i < k; i++) {
+            for (int row = 0; row < rows; row++) {
+                for (int col = 0; col < cols; col++) {
+                    for (int nextRow = row + 1; nextRow < rows; nextRow++) {
+                        if (apples[row][col] - apples[nextRow][col] > 0) {
+                            dp[i][row][col] += dp[i - 1][nextRow][col];
+                            dp[i][row][col] %= MOD;
+                        }
+                    }
+                    for (int nextCol = col + 1; nextCol < cols; nextCol++) {
+                        if (apples[row][col] - apples[row][nextCol] > 0) {
+                            dp[i][row][col] += dp[i - 1][row][nextCol];
+                            dp[i][row][col] %= MOD;
+                        }
+                    }
+                }
+            }
+        }
+        return dp[k - 1][0][0];
+    }
+}

From 93de89d96da86beb4d51d2f67ac261cd7b762adc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 31 Mar 2023 06:43:54 -0700
Subject: [PATCH 1599/2175] Added 4 Keys Keyboard

---
 Medium/4 Keys Keyboard.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/4 Keys Keyboard.java

diff --git a/Medium/4 Keys Keyboard.java b/Medium/4 Keys Keyboard.java
new file mode 100644
index 00000000..2ca4bb8e
--- /dev/null
+++ b/Medium/4 Keys Keyboard.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int maxA(int n) {
+        int[] dp = new int[n + 1];
+        for (int i = 0; i <= n; i++) {
+            dp[i] = i;
+        }
+        for (int i = 0; i <= n - 3; i++) {
+            for (int j = i + 3; j <= Math.min(n, i + 6); j++) {
+                dp[j] = Math.max(dp[j], (j - i - 1) * dp[i]);
+            }
+        }
+        return dp[n];
+    }
+}

From 2cf3328da7d6fd6e6d57a127dcc7ea16d36fc436 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 1 Apr 2023 14:56:24 -0700
Subject: [PATCH 1600/2175] Added Form Smallest Number From Two Digit Arrays

---
 ...Smallest Number From Two Digit Arrays.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Form Smallest Number From Two Digit Arrays.java

diff --git a/Easy/Form Smallest Number From Two Digit Arrays.java b/Easy/Form Smallest Number From Two Digit Arrays.java
new file mode 100644
index 00000000..5ae6bd94
--- /dev/null
+++ b/Easy/Form Smallest Number From Two Digit Arrays.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int minNumber(int[] nums1, int[] nums2) {
+        int[] counter = new int[10];
+        int smallestOne = nums1[0];
+        int smallestTwo = nums2[0];
+        for (int num : nums1) {
+            counter[num]++;
+            smallestOne = Math.min(smallestOne, num);
+        }
+        for (int num : nums2) {
+            counter[num]++;
+            smallestTwo = Math.min(smallestTwo, num);
+        }
+        for (int i = 1; i < counter.length; i++) {
+            if (counter[i] == 2) {
+                return i;
+            }
+        }
+        return Math.min(smallestOne, smallestTwo) * 10 + Math.max(smallestOne, smallestTwo);
+    }
+}

From 2755705abf32b39d6cd207f162dbed899830ab95 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 1 Apr 2023 15:34:33 -0700
Subject: [PATCH 1601/2175] Added Find the Substring With Maximum Cost.java

---
 Medium/Find the Substring With Maximum Cost.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Find the Substring With Maximum Cost.java

diff --git a/Medium/Find the Substring With Maximum Cost.java b/Medium/Find the Substring With Maximum Cost.java
new file mode 100644
index 00000000..24e00548
--- /dev/null
+++ b/Medium/Find the Substring With Maximum Cost.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int maximumCostSubstring(String s, String chars, int[] vals) {
+        Map<Character, Integer> valueMap = new HashMap<>();
+        for (int i = 0; i < chars.length(); i++) {
+            valueMap.put(chars.charAt(i), vals[i]);
+        }
+        int maxCost = 0;
+        int currCost = 0;
+        for (char c : s.toCharArray()) {
+            int currCharCost = valueMap.containsKey(c) ? valueMap.get(c) : (c - 'a' + 1);
+            currCost = Math.max(currCharCost, currCost + currCharCost);
+            maxCost = Math.max(currCost, maxCost);
+        }
+        return maxCost;
+    }
+}

From 273c1f2c71f649579d5312294b8f4e586a509aac Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 1 Apr 2023 15:40:42 -0700
Subject: [PATCH 1602/2175] Added commit-script.sh

---
 commit-script.sh | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100755 commit-script.sh

diff --git a/commit-script.sh b/commit-script.sh
new file mode 100755
index 00000000..90a4f404
--- /dev/null
+++ b/commit-script.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+git add .
+
+if git status | grep -q 'modified'; then
+    status=$(git status | grep 'modified')
+    modified_file=${status##*/}
+    git commit -m "Updated ${modified_file}"
+elif git status | grep -q 'new file:'; then
+    status=$(git status | grep 'new file:')
+    added_file=${status##*/}
+    git commit -m "Added ${added_file}"
+fi
+
+git push

From f2c68be5498d5e5723f1e0ff2892b175f3fa382e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 1 Apr 2023 17:22:58 -0700
Subject: [PATCH 1603/2175] Updated Successful Pairs of Spells and Potions.java

---
 ...uccessful Pairs of Spells and Potions.java | 44 +++++++++----------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/Medium/Successful Pairs of Spells and Potions.java b/Medium/Successful Pairs of Spells and Potions.java
index 40c459c7..8a8e6886 100644
--- a/Medium/Successful Pairs of Spells and Potions.java	
+++ b/Medium/Successful Pairs of Spells and Potions.java	
@@ -1,26 +1,26 @@
 class Solution {
-  public int[] successfulPairs(int[] spells, int[] potions, long success) {
-    int[] result = new int[spells.length];
-    Arrays.sort(potions);
-    for (int i = 0; i < spells.length; i++) {
-      int idx = getSuccessIdx(potions, spells[i], success);
-      result[i] = potions.length - idx;
+    public int[] successfulPairs(int[] spells, int[] potions, long success) {
+        Arrays.sort(potions);
+        int[] result = new int[spells.length];
+        for (int i = 0; i < spells.length; i++) {
+            result[i] = findCountOfSuccessfulPotion(potions, success, (long) spells[i]);
+        }
+        return result;
     }
-    return result;
-  }
-  
-  private int getSuccessIdx(int[] potions, int spell, long success) {
-    int left = 0;
-    int right = potions.length;
-    while (left < right) {
-      int mid = (left + right) / 2;
-      long currSuccess = ((long) potions[mid]) * spell;
-      if (currSuccess >= success) {
-        right = mid;
-      } else {
-        left = mid + 1;
-      }
+    
+    private int findCountOfSuccessfulPotion(int[] potions, long success, long spell) {
+        int left = 0;
+        int right = potions.length - 1;
+        int minIdx = Integer.MAX_VALUE;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (potions[mid] * spell >= success) {
+                minIdx = Math.min(minIdx, mid);
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return minIdx == Integer.MAX_VALUE ? 0 : (potions.length - minIdx);
     }
-    return left;
-  }
 }

From fa1372856b855ae761eb4ce732004b9e07a6d864 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 2 Apr 2023 06:41:44 -0700
Subject: [PATCH 1604/2175] Added Find the Longest Balanced Substring of a
 Binary String.java

---
 ...Balanced Substring of a Binary String.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Find the Longest Balanced Substring of a Binary String.java

diff --git a/Easy/Find the Longest Balanced Substring of a Binary String.java b/Easy/Find the Longest Balanced Substring of a Binary String.java
new file mode 100644
index 00000000..2b1d3f2a
--- /dev/null
+++ b/Easy/Find the Longest Balanced Substring of a Binary String.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int findTheLongestBalancedSubstring(String s) {
+        int maxLength = 0;
+        int idx = 0;
+        while (idx < s.length()) {
+            if (s.charAt(idx) != '0') {
+                idx++;
+                continue;
+            }
+            int zeroCount = 0;
+            while (idx < s.length() && s.charAt(idx) == '0') {
+                idx++;
+                zeroCount++;
+            }
+            int oneCount = 0;
+            while (idx < s.length() && s.charAt(idx) == '1') {
+                idx++;
+                oneCount++;
+            }
+            maxLength = Math.max(maxLength, 2 * Math.min(zeroCount, oneCount));
+                
+        }
+        return maxLength;
+    }
+}

From 3c1247f87aa3f6a704c27682363ad70ded0c696c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 2 Apr 2023 06:48:32 -0700
Subject: [PATCH 1605/2175] Added Convert an Array Into a 2D Array With
 Conditions.java

---
 ...Array Into a 2D Array With Conditions.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Convert an Array Into a 2D Array With Conditions.java

diff --git a/Medium/Convert an Array Into a 2D Array With Conditions.java b/Medium/Convert an Array Into a 2D Array With Conditions.java
new file mode 100644
index 00000000..c774bda6
--- /dev/null
+++ b/Medium/Convert an Array Into a 2D Array With Conditions.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public List<List<Integer>> findMatrix(int[] nums) {
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        for (int num : nums) {
+            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        queue.addAll(frequencyMap.keySet());
+        List<List<Integer>> result = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            List<Integer> row = new ArrayList<>();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                row.add(removed);
+                if (frequencyMap.get(removed) > 1) {
+                    frequencyMap.put(removed, frequencyMap.get(removed) - 1);
+                    queue.add(removed);
+                }
+            }
+            result.add(row);
+        }
+        return result;
+    }
+}

From 1f4411567a5ab8fe45d883cf8d7c2ddc25dd25b8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 3 Apr 2023 06:40:07 -0700
Subject: [PATCH 1606/2175] Updated Boats to Save People.java

---
 Medium/Boats to Save People.java | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Medium/Boats to Save People.java b/Medium/Boats to Save People.java
index 725f18c7..dab79035 100644
--- a/Medium/Boats to Save People.java	
+++ b/Medium/Boats to Save People.java	
@@ -1,16 +1,16 @@
 class Solution {
-  public int numRescueBoats(int[] people, int limit) {
-    Arrays.sort(people);
-    int startIdx = 0;
-    int endIdx = people.length - 1;
-    int count = 0;
-    while (startIdx <= endIdx) {
-      int currWeight = people[endIdx--];
-      if (startIdx <= endIdx && currWeight + people[startIdx] <= limit) {
-        currWeight += people[startIdx++];
-      }
-      count++;
-    } 
-    return count;
-  } 
+    public int numRescueBoats(int[] people, int limit) {
+        Arrays.sort(people);
+        int left = 0;
+        int right = people.length - 1;
+        int count = 0;
+        while (left <= right) {
+            int capacity = people[right--];
+            if (left <= right && capacity + people[left] <= limit) {
+                left++;
+            }
+            count++;
+        }        
+        return count;
+    }
 }

From 3492e1be759604c0f3b28209b92a742c81368132 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 3 Apr 2023 06:52:29 -0700
Subject: [PATCH 1607/2175] Updated Shortest Word Distance III.java

---
 Medium/Shortest Word Distance III.java | 31 +++++++++++++++++---------
 1 file changed, 20 insertions(+), 11 deletions(-)

diff --git a/Medium/Shortest Word Distance III.java b/Medium/Shortest Word Distance III.java
index ba7216c1..fba93082 100644
--- a/Medium/Shortest Word Distance III.java	
+++ b/Medium/Shortest Word Distance III.java	
@@ -1,15 +1,24 @@
 class Solution {
-  public int shortestWordDistance(String[] wordsDict, String word1, String word2) {
-    int minIdxDiff = wordsDict.length;
-    int prevIdx = -1;
-    for (int i = 0; i < wordsDict.length; i++) {
-      if (wordsDict[i].equals(word1) || wordsDict[i].equals(word2)) {
-        if (prevIdx != -1 && (word1.equals(word2) || !wordsDict[prevIdx].equals(wordsDict[i]))) {
-          minIdxDiff = Math.min(minIdxDiff, Math.abs(prevIdx - i));
+    public int shortestWordDistance(String[] wordsDict, String word1, String word2) {
+        int idxOne = -1;
+        int idxTwo = -1;
+        int minDistance = Integer.MAX_VALUE;
+        boolean sameWord = word1.equals(word2);
+        for (int i = 0; i < wordsDict.length; i++) {
+            if (wordsDict[i].equals(word1)) {
+                idxOne = sameWord ? (idxOne == -1 ? i : idxOne) : i; 
+            }
+            if (wordsDict[i].equals(word2)) {
+                idxTwo = sameWord ? (idxOne != i ? i : idxTwo) : i; 
+            }
+            if (idxOne != -1 && idxTwo != -1) {
+                minDistance = Math.min(minDistance, Math.abs(idxOne - idxTwo));
+                if (sameWord) {
+                    idxOne = idxTwo;
+                    idxTwo = -1;
+                }
+            }
         }
-        prevIdx = i;
-      }
+        return minDistance;
     }
-    return minIdxDiff;
-  }
 }

From 004d680823e9846a78ec8afbe2915bb678c6fa35 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 3 Apr 2023 17:22:55 -0700
Subject: [PATCH 1608/2175] Updated Optimal Partition of String.java

---
 Medium/Optimal Partition of String.java | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/Medium/Optimal Partition of String.java b/Medium/Optimal Partition of String.java
index 2c42afa6..68b01d59 100644
--- a/Medium/Optimal Partition of String.java	
+++ b/Medium/Optimal Partition of String.java	
@@ -1,14 +1,14 @@
 class Solution {
-  public int partitionString(String s) {
-    int idx = 0;
-    int count = 0;
-    while (idx < s.length()) {
-      Set<Character> set = new HashSet<>();
-      while (idx < s.length() && set.add(s.charAt(idx))) {
-        idx++;
-      }
-      count++;
+    public int partitionString(String s) {
+        int count = 0;
+        int idx = 0;
+        while (idx < s.length()) {
+            Set<Character> set = new HashSet<>();
+            while (idx < s.length() && set.add(s.charAt(idx))) {
+                idx++;
+            }
+            count++;
+        }
+        return count;
     }
-    return count;
-  }
 }

From 59c5848f72b9f9104b88f60d5a04b8c06fa36412 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 4 Apr 2023 17:42:29 -0700
Subject: [PATCH 1609/2175] Added Minimize Maximum of Array.java

---
 Medium/Minimize Maximum of Array.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Minimize Maximum of Array.java

diff --git a/Medium/Minimize Maximum of Array.java b/Medium/Minimize Maximum of Array.java
new file mode 100644
index 00000000..79d5ee9b
--- /dev/null
+++ b/Medium/Minimize Maximum of Array.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int minimizeArrayValue(int[] nums) {
+        long prefixSum = 0L;
+        long result = 0L;
+        for (int i = 0; i < nums.length; i++) {
+            prefixSum += nums[i];
+            result = Math.max(result, (prefixSum + i) / (i + 1));
+        }
+        return (int) result;
+    }
+}

From 563b41ea825069d095fd01527b23781d69529d08 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 5 Apr 2023 17:31:05 -0700
Subject: [PATCH 1610/2175] Updated Number of Closed Islands.java

---
 Medium/Number of Closed Islands.java | 68 ++++++++++++++--------------
 1 file changed, 33 insertions(+), 35 deletions(-)

diff --git a/Medium/Number of Closed Islands.java b/Medium/Number of Closed Islands.java
index 201b30a3..bc8a9a9e 100644
--- a/Medium/Number of Closed Islands.java	
+++ b/Medium/Number of Closed Islands.java	
@@ -1,40 +1,38 @@
 class Solution {
-  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-  
-  public int closedIsland(int[][] grid) {
-    int closedIslandCount = 0;
-    for (int i = 0; i < grid.length; i++) {
-      for (int j = 0; j < grid[0].length; j++) {
-        if (grid[i][j] == 0 && isSurroundedSuccessfully(grid, i, j)) {
-          closedIslandCount++;
+
+    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+    public int closedIsland(int[][] grid) {
+        int count = 0;
+        boolean[][] visited = new boolean[grid.length][grid[0].length];
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 0 && !visited[i][j] && isClosed(grid, i, j, visited)) {
+                    count++;
+                }
+            }
         }
-      }
+        return count;
     }
-    return closedIslandCount;
-  }
-  
-  private boolean isSurroundedSuccessfully(int[][] grid, int i, int j) {
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{i, j});
-    boolean surroundingCheck = true;
-    while (!queue.isEmpty()) {
-      int[] removed = queue.remove();
-      int x = removed[0];
-      int y = removed[1];
-      if (x < 0 || y < 0 || x >= grid.length || y >= grid[0].length) {
-        surroundingCheck = false;
-        continue;
-      }
-      if (grid[x][y] == 1) {
-        continue;
-      }
-      grid[x][y] = 1;
-      for (int[] dir : DIRS) {
-        int newX = x + dir[0];
-        int newY = y + dir[1];
-        queue.add(new int[]{newX, newY});
-      }
+
+    private boolean isClosed(int[][] grid, int i, int j, boolean[][] visited) {
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{i, j});
+        visited[i][j] = true;
+        boolean closed = true;
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            for (int[] dir : DIRS) {
+                int newX = removed[0] + dir[0];
+                int newY = removed[1] + dir[1];
+                if (newX < 0 || newY < 0 || newX >= grid.length || newY >= grid[0].length) {
+                    closed = false;
+                } else if (grid[newX][newY] == 0 && !visited[newX][newY]) {
+                    queue.add(new int[]{newX, newY});
+                    visited[newX][newY] = true;
+                }
+            }
+        }
+        return closed;
     }
-    return surroundingCheck;
-  }
 }

From a51ef04068f7a284bb74b5a41aeffb4c3c5c81a3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 6 Apr 2023 17:34:58 -0700
Subject: [PATCH 1611/2175] Updated Number of Enclaves.java

---
 Medium/Number of Enclaves.java | 60 ++++++++++++++++++++--------------
 1 file changed, 35 insertions(+), 25 deletions(-)

diff --git a/Medium/Number of Enclaves.java b/Medium/Number of Enclaves.java
index 105942a1..afacc77a 100644
--- a/Medium/Number of Enclaves.java	
+++ b/Medium/Number of Enclaves.java	
@@ -1,30 +1,40 @@
 class Solution {
-  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-
-  public int numEnclaves(int[][] grid) {
-    Queue<int[]> queue = new LinkedList<>();
-    int result = 0;
-    for (int i = 0; i < grid.length; i++) {
-      for (int j = 0; j < grid[0].length; j++) {
-        result += grid[i][j];
-        if (i * j == 0 || i == grid.length - 1 || j == grid[i].length - 1) {
-          queue.add(new int[]{i, j});
+    
+    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    
+    public int numEnclaves(int[][] grid) {
+        int count = 0;
+        boolean[][] visited = new boolean[grid.length][grid[0].length];
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1 && !visited[i][j]) {
+                    count += getClosedEnclaveCount(grid, i, j, visited);
+                }
+            }
         }
-      }
+        return count;
     }
-    while (!queue.isEmpty()) {
-      int[] removed = queue.remove();
-      int x = removed[0];
-      int y = removed[1];
-      if (x < 0 || y < 0 || x == grid.length || y == grid[0].length || grid[x][y] != 1) {
-        continue;
-      }
-      grid[x][y] = 0;
-      result--;
-      for (int[] dir : DIRS) {
-        queue.add(new int[]{x + dir[0], y + dir[1]});
-      }
+    
+    private int getClosedEnclaveCount(int[][] grid, int i, int j, boolean[][] visited) {
+        boolean isClosed = true;
+        int enclaveCount = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{i, j});
+        visited[i][j] = true;
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            enclaveCount++;
+            for (int[] dir : DIRS) {
+                int newX = removed[0] + dir[0];
+                int newY = removed[1] + dir[1];
+                if (newX < 0 || newY < 0 || newX >= grid.length || newY >= grid[0].length) {
+                    isClosed = false;
+                } else if (grid[newX][newY] == 1 && !visited[newX][newY]) {
+                    visited[newX][newY] = true;
+                    queue.add(new int[]{newX, newY});
+                }
+            }
+        }
+        return isClosed ? enclaveCount : 0;
     }
-    return result;
-  }
 }

From dce1f7776febe51afbd62b42e3ceb65683d8aeb4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 7 Apr 2023 17:05:27 -0700
Subject: [PATCH 1612/2175] Updated Clone Graph.java

---
 Medium/Clone Graph.java | 39 ++++++++++++++++++---------------------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/Medium/Clone Graph.java b/Medium/Clone Graph.java
index 47a4ba95..cddb7b81 100644
--- a/Medium/Clone Graph.java	
+++ b/Medium/Clone Graph.java	
@@ -3,17 +3,14 @@
 class Node {
     public int val;
     public List<Node> neighbors;
-    
     public Node() {
         val = 0;
         neighbors = new ArrayList<Node>();
     }
-    
     public Node(int _val) {
         val = _val;
         neighbors = new ArrayList<Node>();
     }
-    
     public Node(int _val, ArrayList<Node> _neighbors) {
         val = _val;
         neighbors = _neighbors;
@@ -22,24 +19,24 @@ public Node(int _val, ArrayList<Node> _neighbors) {
 */
 
 class Solution {
-  public Node cloneGraph(Node node) {
-    if (node == null) {
-      return null;
-    }
-    Map<Node, Node> map = new HashMap<>();
-    Queue<Node> queue = new LinkedList<>();
-    queue.add(node);
-    map.put(node, new Node(node.val));
-    while (!queue.isEmpty()) {
-      Node removed = queue.remove();
-      for (Node neighbor : removed.neighbors) {
-        if (!map.containsKey(neighbor)) {
-          map.put(neighbor, new Node(neighbor.val));
-          queue.add(neighbor);
+    public Node cloneGraph(Node node) {
+        if (node == null) {
+            return null;
+        }
+        Map<Node, Node> map = new HashMap();
+        Queue<Node> queue = new LinkedList<>();
+        queue.add(node);
+        map.put(node, new Node(node.val));
+        while (!queue.isEmpty()) {
+            Node removed = queue.remove();
+            for (Node neighbor : removed.neighbors) {
+                if (!map.containsKey(neighbor)) {
+                    map.put(neighbor, new Node(neighbor.val));
+                    queue.add(neighbor);
+                }
+                map.get(removed).neighbors.add(map.get(neighbor));
+            }
         }
-        map.get(removed).neighbors.add(map.get(neighbor));
-      }
+        return map.get(node);
     }
-    return map.get(node);
-  }
 }

From cb72a61686b69ac51ca4359093e9f288d07e0305 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 7 Apr 2023 17:09:44 -0700
Subject: [PATCH 1613/2175] Updated Find Anagram Mappings.java

---
 Easy/Find Anagram Mappings.java | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/Easy/Find Anagram Mappings.java b/Easy/Find Anagram Mappings.java
index 2a7c34e3..3650db78 100644
--- a/Easy/Find Anagram Mappings.java	
+++ b/Easy/Find Anagram Mappings.java	
@@ -1,12 +1,13 @@
 class Solution {
-  public int[] anagramMappings(int[] nums1, int[] nums2) {
-    Map<Integer, Integer> indexMapping = new HashMap<>();
-    for (int i = 0; i < nums2.length; i++) {
-      indexMapping.put(nums2[i], i);
+    public int[] anagramMappings(int[] nums1, int[] nums2) {
+        Map<Integer, Integer> indexMap = new HashMap<>();
+        for (int i = 0; i < nums2.length; i++) {
+            indexMap.putIfAbsent(nums2[i], i);
+        }
+        int[] result = new int[nums1.length];
+        for (int i = 0; i < nums1.length; i++) {
+            result[i] = indexMap.get(nums1[i]);
+        }
+        return result;
     }
-    for (int i = 0; i < nums1.length; i++) {
-      nums1[i] = indexMapping.get(nums1[i]);
-    }
-    return nums1;
-  }
 }

From 7b11656984c2ed24185dccf802063f1286e5f1c8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 9 Apr 2023 09:21:10 -0700
Subject: [PATCH 1614/2175] Added Largest Color Value in a Directed Graph.java

---
 ...rgest Color Value in a Directed Graph.java | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Hard/Largest Color Value in a Directed Graph.java

diff --git a/Hard/Largest Color Value in a Directed Graph.java b/Hard/Largest Color Value in a Directed Graph.java
new file mode 100644
index 00000000..2d2fe6d5
--- /dev/null
+++ b/Hard/Largest Color Value in a Directed Graph.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public int largestPathValue(String colors, int[][] edges) {
+        int n = colors.length();
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        int[] indegree = new int[n];
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>())
+                .add(edge[1]);
+            indegree[edge[1]]++;
+        }
+        int[][] count = new int[n][26];
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+        int result = 1;
+        int seen = 0;
+        while (!queue.isEmpty()) {
+            int node = queue.remove();
+            result = Math.max(result, ++count[node][colors.charAt(node) - 'a']);
+            seen++;
+            if (!graph.containsKey(node)) {
+                continue;
+            }
+            for (int neighbor : graph.get(node)) {
+                for (int i = 0; i < 26; i++) {
+                    count[neighbor][i] = Math.max(count[neighbor][i], count[node][i]);
+                }
+                indegree[neighbor]--;
+                if (indegree[neighbor] == 0) {
+                    queue.add(neighbor);
+                }
+            }
+        }
+        return seen < n ? -1 : result;
+    }
+}

From b9add47cbe0e3be8dac61e3cf12402cfda6754ae Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 9 Apr 2023 09:28:45 -0700
Subject: [PATCH 1615/2175] Added Prime In Diagonal.java

---
 Easy/Prime In Diagonal.java | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Easy/Prime In Diagonal.java

diff --git a/Easy/Prime In Diagonal.java b/Easy/Prime In Diagonal.java
new file mode 100644
index 00000000..16b34fda
--- /dev/null
+++ b/Easy/Prime In Diagonal.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int diagonalPrime(int[][] nums) {
+        int n = nums.length;
+        int maxPrime = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if ((i == j || i + j == n - 1) && isPrime(nums[i][j])) {
+                    maxPrime = Math.max(maxPrime, nums[i][j]);
+                }
+            }
+        }
+        return maxPrime;
+    }
+    
+    private static boolean isPrime(int n) {
+        if (n <= 1) {
+            return false;
+        }
+        if (n == 2) {
+            return true;
+        }
+        int midPoint = ((int) Math.sqrt(n)) + 1;
+        for (int i = 2; i <= midPoint; i++) {
+            if (n % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    } 
+}

From 342118382d4ce4c5cca25587e1efce1fa1dca3ed Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 10 Apr 2023 17:43:08 -0700
Subject: [PATCH 1616/2175] Update Removing Stars From a String.java

---
 Medium/Removing Stars From a String.java | 28 ++++++++++++------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Medium/Removing Stars From a String.java b/Medium/Removing Stars From a String.java
index 0cb79bea..9278128a 100644
--- a/Medium/Removing Stars From a String.java	
+++ b/Medium/Removing Stars From a String.java	
@@ -1,17 +1,17 @@
 class Solution {
-  public String removeStars(String s) {
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-      if (c == '*') {
-        stack.pop();
-      } else {
-        stack.push(c);
-      }
+    public String removeStars(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (c == '*') {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
     }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append(stack.pop());
-    }
-    return sb.reverse().toString();
-  }
 }

From f2e1d1fe4f8c7f95f38292280ee6f59b3de0565a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 11 Apr 2023 17:24:14 -0700
Subject: [PATCH 1617/2175] Update Simplify Path.java

---
 Medium/Simplify Path.java | 37 +++++++++++++++++++------------------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/Medium/Simplify Path.java b/Medium/Simplify Path.java
index 51c19971..b04ccd5e 100644
--- a/Medium/Simplify Path.java	
+++ b/Medium/Simplify Path.java	
@@ -1,22 +1,23 @@
 class Solution {
-  public String simplifyPath(String path) {
-    Stack<String> stack = new Stack<>();
-    String[] splits = path.split("/");
-    for (String split : splits) {
-      if (split.equals("") || split.equals(".")) {
-        continue;
-      } else if (split.equals("..")) {
-        if (!stack.isEmpty()) {
-          stack.pop();
+    public String simplifyPath(String path) {
+        Stack<String> stack = new Stack<>();
+        String[] splits = path.split("\\/");
+        for (String split : splits) {
+            if (split.equals(".") || split.equals("/") || split.isBlank()) {
+                continue;
+            }
+            if (split.equals("..")) {
+                if (!stack.isEmpty()) {
+                    stack.pop();
+                }
+            } else {
+                stack.push(split);
+            }
         }
-      } else {
-        stack.push(split);
-      }
-    }
-    StringBuilder resultingPath = new StringBuilder();
-    while (!stack.isEmpty()) {
-      resultingPath.insert(0, stack.pop()).insert(0, "/");
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.insert(0, stack.pop()).insert(0, "/");
+        }
+        return sb.length() == 0 ? "/" : sb.toString();
     }
-    return resultingPath.length() == 0 ? "/" : resultingPath.toString();
-  }
 }

From 2b4883da7ff2d566271460143c1dda5bea817f04 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 12 Apr 2023 17:16:48 -0700
Subject: [PATCH 1618/2175] Updated Validate Stack Sequences.java

---
 Medium/Validate Stack Sequences.java | 36 +++++++++++++---------------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/Medium/Validate Stack Sequences.java b/Medium/Validate Stack Sequences.java
index 87d61d31..64ae1452 100644
--- a/Medium/Validate Stack Sequences.java	
+++ b/Medium/Validate Stack Sequences.java	
@@ -1,22 +1,20 @@
 class Solution {
-  public boolean validateStackSequences(int[] pushed, int[] popped) {
-    Stack<Integer> stack = new Stack<>();
-    int pushIdx = 0;
-    int popIdx = 0;
-    while (pushIdx < pushed.length) {
-      while (!stack.isEmpty() && popped[popIdx] == stack.peek()) {
-        stack.pop();
-        popIdx++;
-      }
-      stack.push(pushed[pushIdx++]);
+    public boolean validateStackSequences(int[] pushed, int[] popped) {
+        Stack<Integer> stack = new Stack<>();
+        int pushedIdx = 0;
+        int poppedIdx = 0;
+        while (pushedIdx < pushed.length && poppedIdx < popped.length) {
+            if (!stack.isEmpty() && stack.peek() == popped[poppedIdx]) {
+                stack.pop();
+                poppedIdx++;
+            } else {
+                stack.push(pushed[pushedIdx++]);
+            }
+        }
+        while (poppedIdx < popped.length && !stack.isEmpty() && stack.peek() == popped[poppedIdx]) {
+            stack.pop();
+            poppedIdx++;
+        }
+        return pushedIdx == pushed.length && poppedIdx == popped.length;
     }
-    while (popIdx < popped.length) {
-      if (stack.isEmpty() || stack.peek() != popped[popIdx]) {
-        return false;
-      }
-      stack.pop();
-      popIdx++;
-    }
-    return true;
-  }
 }

From c1335270bf916fa7deab3b7e5f260e23ee3433bf Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 13 Apr 2023 17:56:14 -0700
Subject: [PATCH 1619/2175] Updated Longest Palindromic Subsequence.java

---
 Medium/Longest Palindromic Subsequence.java | 47 +++++++++------------
 1 file changed, 19 insertions(+), 28 deletions(-)

diff --git a/Medium/Longest Palindromic Subsequence.java b/Medium/Longest Palindromic Subsequence.java
index 5d9d4dfd..85c6c5e7 100644
--- a/Medium/Longest Palindromic Subsequence.java	
+++ b/Medium/Longest Palindromic Subsequence.java	
@@ -1,34 +1,25 @@
 class Solution {
     public int longestPalindromeSubseq(String s) {
-        int[][] temp = new int[s.length()][s.length()];
-        for(int i=0;i<s.length();i++) {
-            temp[i][i] = 1;
+        int n = s.length();
+        int[][] dp = new int[n][n];
+        return helper(s, 0, n - 1, dp);
+    }
+    
+    private int helper(String s, int startIdx, int endIdx, int[][] dp) {
+        if (dp[startIdx][endIdx] != 0) {
+            return dp[startIdx][endIdx];
+        }
+        if (startIdx > endIdx) {
+            return 0;
         }
-        
-        int j;
-        
-        for (int cl=2;cl <= s.length();cl++) {
-            for (int i=0;i<s.length()-cl+1;i++) {
-                j = i + cl - 1;
-                if (s.charAt(i) == s.charAt(j) && cl == 2)
-                   temp[i][j] = 2;
-                else if (s.charAt(i) == s.charAt(j))
-                   temp[i][j] = temp[i+1][j-1] + 2;
-                else
-                   temp[i][j] = Math.max(temp[i][j-1], temp[i+1][j]);
-            }
+        if (startIdx == endIdx) {
+            return 1;
         }
-        
-        return temp[0][s.length()-1];
+        if (s.charAt(startIdx) == s.charAt(endIdx)) {
+            dp[startIdx][endIdx] = helper(s, startIdx + 1, endIdx - 1, dp) + 2;
+        } else {
+            dp[startIdx][endIdx] = Math.max(helper(s, startIdx + 1, endIdx, dp), helper(s, startIdx, endIdx - 1, dp));
+        }
+        return dp[startIdx][endIdx];
     }
-    
-//     public int longestPalindromeSubseq(String s, int l, int len) {
-//         if (len == 1) return 1;
-//         if (len == 0) return 0;
-        
-//         if (s.charAt(l) == s.charAt(l+len-1)) return 2 + longestPalindromeSubseq(s, l+1, len-2);
-//         else {
-//             return Math.max(longestPalindromeSubseq(s,l+1,len-1), longestPalindromeSubseq(s,l, len-1));
-//         }
-//     }
 }

From 2f5e628f6f43e6c92d1c1656aea4458f16575144 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 15 Apr 2023 07:38:01 -0700
Subject: [PATCH 1620/2175] Added Maximum Value of K Coins From Piles.java

---
 Hard/Maximum Value of K Coins From Piles.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Hard/Maximum Value of K Coins From Piles.java

diff --git a/Hard/Maximum Value of K Coins From Piles.java b/Hard/Maximum Value of K Coins From Piles.java
new file mode 100644
index 00000000..08fbc802
--- /dev/null
+++ b/Hard/Maximum Value of K Coins From Piles.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int maxValueOfCoins(List<List<Integer>> piles, int k) {
+        int n = piles.size();
+        int[][] dp = new int[n + 1][k + 1];
+        for (int i = 1; i <= n; i++) {
+            for (int coins = 0; coins <= k; coins++) {
+                int currSum = 0;
+                for (int currCoins = 0; 
+                     currCoins <= Math.min((int) piles.get(i - 1).size(), coins); 
+                     currCoins++) {
+                    if (currCoins > 0) {
+                        currSum += piles.get(i - 1).get(currCoins - 1);
+                    }
+                    dp[i][coins] = Math.max(dp[i][coins], dp[i - 1][coins - currCoins] + currSum);
+                }
+            }
+        }
+        return dp[n][k];
+    }
+}

From 3dce5914f8a2e6d0ea088801e34c7c1ea4991679 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 16 Apr 2023 08:17:40 -0700
Subject: [PATCH 1621/2175] Added Number of Ways to Form a Target String Given
 a Dictionary.java

---
 ...rm a Target String Given a Dictionary.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Hard/Number of Ways to Form a Target String Given a Dictionary.java

diff --git a/Hard/Number of Ways to Form a Target String Given a Dictionary.java b/Hard/Number of Ways to Form a Target String Given a Dictionary.java
new file mode 100644
index 00000000..a6354f1f
--- /dev/null
+++ b/Hard/Number of Ways to Form a Target String Given a Dictionary.java	
@@ -0,0 +1,28 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int numWays(String[] words, String target) {
+        int m = target.length();
+        int k = words[0].length();
+        int[][] count = new int[26][k];
+        for (int i = 0; i < k; i++) {
+            for (String word : words) {
+                count[word.charAt(i) - 'a'][i]++;
+            }
+        }
+        long[][] dp = new long[m + 1][k + 1];
+        dp[0][0] = 1l;
+        for (int i = 0; i <= m; i++) {
+            for (int j = 0; j < k; j++) {
+                if (i < m) {
+                    dp[i + 1][j + 1] += count[target.charAt(i) - 'a'][j] * dp[i][j];
+                    dp[i + 1][j + 1] %= MOD;
+                }
+                dp[i][j + 1] += dp[i][j];
+                dp[i][j + 1] %= MOD;
+            }
+        }
+        return (int) dp[m][k];
+    }
+}

From a102b912bc5ea4825ae8304e207846e6b6ff3982 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 16 Apr 2023 08:26:36 -0700
Subject: [PATCH 1622/2175] Added Find the Width of Columns of a Grid.java

---
 Easy/Find the Width of Columns of a Grid.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Find the Width of Columns of a Grid.java

diff --git a/Easy/Find the Width of Columns of a Grid.java b/Easy/Find the Width of Columns of a Grid.java
new file mode 100644
index 00000000..843813b9
--- /dev/null
+++ b/Easy/Find the Width of Columns of a Grid.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int[] findColumnWidth(int[][] grid) {
+        int[] result = new int[grid[0].length];
+        for (int i = 0; i < grid[0].length; i++) {
+            int maxLength = 0;
+            for (int j = 0; j < grid.length; j++) {
+                maxLength = Math.max(maxLength, String.valueOf(grid[j][i]).length());
+            }
+            result[i] = maxLength;
+        }
+        return result;
+    }
+}

From 5201ec217eae6affc0e683fd8c66370f5c03ecbb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 16 Apr 2023 17:14:52 -0700
Subject: [PATCH 1623/2175] Updated Kids With the Greatest Number of
 Candies.java

---
 ...ids With the Greatest Number of Candies.java | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/Easy/Kids With the Greatest Number of Candies.java b/Easy/Kids With the Greatest Number of Candies.java
index 79789d90..67e2441d 100644
--- a/Easy/Kids With the Greatest Number of Candies.java	
+++ b/Easy/Kids With the Greatest Number of Candies.java	
@@ -1,13 +1,10 @@
 class Solution {
-  public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
-    int maxCandyCount = 0;
-    for (int candy : candies) {
-      maxCandyCount = Math.max(maxCandyCount, candy);
+    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
+        final int maxCandy = Arrays.stream(candies)
+            .max()
+            .orElse(0);
+        return Arrays.stream(candies)
+            .mapToObj(candy -> candy + extraCandies >= maxCandy)
+            .collect(Collectors.toList());
     }
-    List<Boolean> result = new ArrayList<>();
-    for (int candy : candies) {
-      result.add((candy + extraCandies) >= maxCandyCount);
-    }
-    return result;
-  }
 }

From 73f6e1580b295618a806697790dbae7c6c32b500 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 17 Apr 2023 10:19:07 -0700
Subject: [PATCH 1624/2175] Create Row With Maximum Ones.java

---
 Easy/Row With Maximum Ones.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Row With Maximum Ones.java

diff --git a/Easy/Row With Maximum Ones.java b/Easy/Row With Maximum Ones.java
new file mode 100644
index 00000000..e1d32424
--- /dev/null
+++ b/Easy/Row With Maximum Ones.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] rowAndMaximumOnes(int[][] mat) {
+        int maxOnes = 0;
+        int maxOnesRow = 0;
+        for (int i = 0; i < mat.length; i++) {
+            int oneCount = 0;
+            for (int num : mat[i]) {
+                oneCount += num == 1 ? 1 : 0;
+            }
+            if (oneCount > maxOnes) {
+                maxOnes = oneCount;
+                maxOnesRow = i;
+            }
+        }
+        return new int[]{maxOnesRow, maxOnes};
+    }
+}

From a43654c560890c4c0ee66780a7c1da9a56389303 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 17 Apr 2023 10:24:42 -0700
Subject: [PATCH 1625/2175] Create Find the Score of All Prefixes of an
 Array.java

---
 ...d the Score of All Prefixes of an Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Find the Score of All Prefixes of an Array.java

diff --git a/Medium/Find the Score of All Prefixes of an Array.java b/Medium/Find the Score of All Prefixes of an Array.java
new file mode 100644
index 00000000..ff88ca98
--- /dev/null
+++ b/Medium/Find the Score of All Prefixes of an Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public long[] findPrefixScore(int[] nums) {
+        int[] conver = new int[nums.length];
+        int max = nums[0];
+        for (int i = 0; i < nums.length; i++) {
+            max = Math.max(max, nums[i]);
+            conver[i] = nums[i] + max;
+        }
+        long[] result = new long[nums.length];
+        long score = 0;
+        for (int i = 0; i < nums.length; i++) {
+            score += conver[i];
+            result[i] = score;
+        }
+        return result;
+    }
+}

From 2239630cc15d051a58ff0fba730d329607fa909b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 17 Apr 2023 17:22:14 -0700
Subject: [PATCH 1626/2175] Updated Merge Strings Alternately.java

---
 Easy/Merge Strings Alternately.java | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/Easy/Merge Strings Alternately.java b/Easy/Merge Strings Alternately.java
index 65fb9904..7b851597 100644
--- a/Easy/Merge Strings Alternately.java	
+++ b/Easy/Merge Strings Alternately.java	
@@ -1,19 +1,16 @@
 class Solution {
-  public String mergeAlternately(String word1, String word2) {
-    int idx1 = 0;
-    int idx2 = 0;
-    StringBuilder sb = new StringBuilder();
-    boolean first = true;
-    while (idx1 < word1.length() && idx2 < word2.length()) {
-      sb.append(first ? word1.charAt(idx1++) : word2.charAt(idx2++));
-      first = !first;
+    public String mergeAlternately(String word1, String word2) {
+        StringBuilder sb = new StringBuilder();
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < word1.length() || idxTwo < word2.length()) {
+            if (idxOne < word1.length()) {
+                sb.append(word1.charAt(idxOne++));
+            }
+            if (idxTwo < word2.length()) {
+                sb.append(word2.charAt(idxTwo++));
+            }
+        }
+        return sb.toString();
     }
-    while (idx1 < word1.length()) {
-      sb.append(word1.charAt(idx1++));
-    }
-    while (idx2 < word2.length()) {
-      sb.append(word2.charAt(idx2++));
-    }
-    return sb.toString();
-  }
 }

From fbc0111a75d33ae06cebb128620d24e609a778f7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 18 Apr 2023 17:22:15 -0700
Subject: [PATCH 1627/2175] Updated Longest ZigZag Path in a Binary Tree.java

---
 .../Longest ZigZag Path in a Binary Tree.java | 52 +++++++++++--------
 1 file changed, 29 insertions(+), 23 deletions(-)

diff --git a/Medium/Longest ZigZag Path in a Binary Tree.java b/Medium/Longest ZigZag Path in a Binary Tree.java
index bdc3e8f9..71e32231 100644
--- a/Medium/Longest ZigZag Path in a Binary Tree.java	
+++ b/Medium/Longest ZigZag Path in a Binary Tree.java	
@@ -4,33 +4,39 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  int max;
-  public int longestZigZag(TreeNode root) {
-    if (root == null) {
-      return -1;
+    
+    private enum DIRECTION {
+        LEFT, RIGHT;
     }
-    max = 0;
-    helper(root.right, 1, true);
-    helper(root.left, 1, false);
-    return max;
-  } 
-  
-  private void helper(TreeNode root, int step, boolean isRight) {
-    if (root == null) {
-      return;
+    
+    public int longestZigZag(TreeNode root) {
+        int[] pathLength = {0};
+        dfs(root, DIRECTION.LEFT, 0, pathLength);
+        dfs(root, DIRECTION.RIGHT, 0, pathLength);
+        return pathLength[0];
     }
-    max = Math.max(max, step);
-    if (isRight) {
-      helper(root.left, step + 1, false);
-      helper(root.right, 1, true);
+    
+    private void dfs(TreeNode node, DIRECTION direction, int steps, int[] pathLength) {
+        if (node == null) {
+            return;
+        }
+        pathLength[0] = Math.max(pathLength[0], steps);
+        if (direction == DIRECTION.LEFT) {
+            dfs(node.left, DIRECTION.RIGHT, steps + 1, pathLength);
+            dfs(node.right, DIRECTION.LEFT, 1, pathLength);
+        } else {
+            dfs(node.left, DIRECTION.RIGHT, 1, pathLength);
+            dfs(node.right, DIRECTION.LEFT, steps + 1, pathLength);
+        }
     }
-    else {
-      helper(root.right, step + 1, true);
-      helper(root.left, 1, false);
-    }
-  }
 }

From 3e4377a9e34ebf03aedda62a6af92ee7ad4b4e89 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 20 Apr 2023 07:51:31 -0700
Subject: [PATCH 1628/2175] Updated Maximum Width of Binary Tree.java

---
 Medium/Maximum Width of Binary Tree.java | 51 +++++++++++-------------
 1 file changed, 23 insertions(+), 28 deletions(-)

diff --git a/Medium/Maximum Width of Binary Tree.java b/Medium/Maximum Width of Binary Tree.java
index 3610e37d..d5edef7e 100644
--- a/Medium/Maximum Width of Binary Tree.java	
+++ b/Medium/Maximum Width of Binary Tree.java	
@@ -14,35 +14,30 @@
  * }
  */
 class Solution {
-  public int widthOfBinaryTree(TreeNode root) {
-    int maxWidth = 0;
-    Queue<TreeNode> queue = new LinkedList<>();
-    Map<TreeNode, Integer> map = new HashMap<>();
-    map.put(root, 1);
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      int start = 0;
-      int end = 0;
-      for (int i = 0; i < size; i++) {
-        TreeNode node = queue.poll();
-        if (i == 0) {
-          start = map.get(node);
+    public int widthOfBinaryTree(TreeNode root) {
+        if (root == null) {
+            return 0;
         }
-        if (i == size - 1) {
-          end = map.get(node);
+        Queue<NodeColIndex> queue = new LinkedList<>();
+        queue.add(new NodeColIndex(root, 0));
+        int maxWidth = 0;
+        while (!queue.isEmpty()) {
+            NodeColIndex head = queue.peek();
+            int levelSize = queue.size();
+            for (int i = 0; i < levelSize; i++) {
+                NodeColIndex removed = queue.remove();
+                TreeNode node = removed.node;
+                if (node.left != null) {
+                    queue.add(new NodeColIndex(node.left, 2 * removed.colIdx));
+                }
+                if (node.right != null) {
+                    queue.add(new NodeColIndex(node.right, 2 * removed.colIdx + 1));
+                }
+                maxWidth = Math.max(maxWidth, removed.colIdx - head.colIdx + 1);
+            }
         }
-        if (node.left != null) {
-          map.put(node.left, map.get(node) * 2);
-          queue.add(node.left);
-        }
-        if (node.right != null) {
-          map.put(node.right, map.get(node) * 2 + 1);
-          queue.add(node.right);
-        }
-      }
-      maxWidth = Math.max(maxWidth, end - start + 1);
+        return maxWidth;
     }
-    return maxWidth;
-  }
+    
+    private record NodeColIndex(TreeNode node, int colIdx) {}
 }

From 699c847f02b498efa1696178f758e9b5db9fdaa5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 20 Apr 2023 17:13:32 -0700
Subject: [PATCH 1629/2175] Create Profitable Schemes.java

---
 Hard/Profitable Schemes.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Hard/Profitable Schemes.java

diff --git a/Hard/Profitable Schemes.java b/Hard/Profitable Schemes.java
new file mode 100644
index 00000000..7a1cabc4
--- /dev/null
+++ b/Hard/Profitable Schemes.java	
@@ -0,0 +1,23 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
+        Integer[][][] dp = new Integer[101][101][101];
+        return helper(0, 0, 0, n, minProfit, group, profit, dp);
+    }
+    
+    private int helper(int pos, int count, int profit, int n, int minProfit, int[] group, int[] profits, Integer[][][] dp) {
+        if (pos == group.length) {
+            return profit >= minProfit ? 1 : 0;
+        }
+        if (dp[pos][count][profit] != null) {
+            return dp[pos][count][profit];
+        }
+        int totalWays = helper(pos + 1, count, profit, n, minProfit, group, profits, dp);
+        if (count + group[pos] <= n) {
+            totalWays += helper(pos + 1, count + group[pos], Math.min(minProfit, profit + profits[pos]), n, minProfit, group, profits, dp);
+        }
+        return dp[pos][count][profit] = totalWays % MOD;
+    }
+}

From 2b7e3f0123b892d91688ef9ee93d84f84276e373 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 21 Apr 2023 06:16:26 -0700
Subject: [PATCH 1630/2175] Added Find the Maximum Divisibility Score.java

---
 .../Find the Maximum Divisibility Score.java  | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Find the Maximum Divisibility Score.java

diff --git a/Medium/Find the Maximum Divisibility Score.java b/Medium/Find the Maximum Divisibility Score.java
new file mode 100644
index 00000000..2e33ee9a
--- /dev/null
+++ b/Medium/Find the Maximum Divisibility Score.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxDivScore(int[] nums, int[] divisors) {
+        int maxScore = -1;
+        int maxScoreCandidate = -1;
+        for (int divisor : divisors) {
+            int currScore = 0;
+            for (int num : nums) {
+                currScore += num % divisor == 0 ? 1 : 0;
+            }
+            if (currScore > maxScore) {
+                maxScore = currScore;
+                maxScoreCandidate = divisor;
+            } else if (currScore == maxScore) {
+                maxScoreCandidate = Math.min(maxScoreCandidate, divisor);
+            }
+        }
+        return maxScoreCandidate;
+    }
+}

From f2304067c2c542b3e3bdb519f6d2a62705cc9c2b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 21 Apr 2023 14:23:14 -0700
Subject: [PATCH 1631/2175] Update Trapping Rain Water.java

---
 Hard/Trapping Rain Water.java | 40 ++++++++++++++++-------------------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/Hard/Trapping Rain Water.java b/Hard/Trapping Rain Water.java
index 8747d76b..263ab08a 100644
--- a/Hard/Trapping Rain Water.java	
+++ b/Hard/Trapping Rain Water.java	
@@ -1,27 +1,23 @@
 class Solution {
-  public int trap(int[] height) {
-    int leftIdx = 0;
-    int rightIdx = height.length - 1;
-    int leftMax = 0;
-    int rightMax = 0;
-    int result = 0;
-    while (leftIdx < rightIdx) {
-      if (height[leftIdx] < height[rightIdx]) {
-        if (height[leftIdx] >= leftMax) {
-          leftMax = height[leftIdx];
-        } else {
-          result += leftMax - height[leftIdx];
+    public int trap(int[] height) {
+        if (height.length == 0) {
+            return 0;
         }
-        leftIdx++;
-      } else {
-        if (height[rightIdx] >= rightMax) {
-          rightMax = height[rightIdx];
-        } else {
-          result += rightMax - height[rightIdx];
+        int n = height.length;
+        int[] leftMax = new int[n];
+        leftMax[0] = height[0];
+        for (int i = 1; i < n; i++) {
+            leftMax[i] = Math.max(height[i], leftMax[i - 1]);
         }
-        rightIdx--;
-      }
+        int[] rightMax = new int[n];
+        rightMax[n - 1] = height[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], height[i]);
+        }
+        int result = 0;
+        for (int i = 1; i < n - 1; i++) {
+            result += Math.min(leftMax[i], rightMax[i]) - height[i];
+        }
+        return result;
     }
-    return result;
-  }
 }

From 5b31e8013879b0630a52847fde34409d4b492e6d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Apr 2023 07:45:07 -0700
Subject: [PATCH 1632/2175] Create Minimum Insertion Steps to Make a String
 Palindrome.java

---
 ...ion Steps to Make a String Palindrome.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Hard/Minimum Insertion Steps to Make a String Palindrome.java

diff --git a/Hard/Minimum Insertion Steps to Make a String Palindrome.java b/Hard/Minimum Insertion Steps to Make a String Palindrome.java
new file mode 100644
index 00000000..3ffd2f07
--- /dev/null
+++ b/Hard/Minimum Insertion Steps to Make a String Palindrome.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int minInsertions(String s) {
+        int n = s.length();
+        return n - lcs(s, new StringBuilder(s).reverse().toString(), n, n);
+    }
+    
+    private int lcs(String s1, String s2, int m, int n) {
+        int[][] dp = new int[m + 1][n + 1];
+        for (int i = 0; i <= m; i++) {
+            for (int j = 0; j <= n; j++) {
+                if (i == 0 || j == 0) {
+                    dp[i][j] = 0;
+                } else if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+        return dp[m][n];
+    }
+}

From f3ffae5aa4cca3fefe4579592443150be48f6ab1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 23 Apr 2023 06:49:51 -0700
Subject: [PATCH 1633/2175] Added Restore The Array.java

---
 Hard/Restore The Array.java | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Hard/Restore The Array.java

diff --git a/Hard/Restore The Array.java b/Hard/Restore The Array.java
new file mode 100644
index 00000000..9b6ffc76
--- /dev/null
+++ b/Hard/Restore The Array.java	
@@ -0,0 +1,31 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int numberOfArrays(String s, int k) {
+        int n = s.length();
+        int[] dp = new int[n + 1];
+        return dfs(dp, 0, s, k);
+    }
+    
+    private int dfs(int[] dp, int start, String s, int k) {
+        if (dp[start] != 0) {
+            return dp[start];
+        }
+        if (start == s.length()) {
+            return 1;
+        }
+        if (s.charAt(start) == '0') {
+            return 0;
+        }
+        int count = 0;
+        for (int end = start; end < s.length(); end++) {
+            String currNum = s.substring(start, end + 1);
+            if (Long.parseLong(currNum) > k) {
+                break;
+            }
+            count = (count + dfs(dp, end + 1, s, k)) % MOD;
+        }
+        return dp[start] = count;
+    }
+}

From db9a788061764ae30471659808fd59af3d03c475 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 23 Apr 2023 06:53:00 -0700
Subject: [PATCH 1634/2175] Added Calculate Delayed Arrival Time.java

---
 Easy/Calculate Delayed Arrival Time.java | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 Easy/Calculate Delayed Arrival Time.java

diff --git a/Easy/Calculate Delayed Arrival Time.java b/Easy/Calculate Delayed Arrival Time.java
new file mode 100644
index 00000000..47367e00
--- /dev/null
+++ b/Easy/Calculate Delayed Arrival Time.java	
@@ -0,0 +1,6 @@
+class Solution {
+    public int findDelayedArrivalTime(int arrivalTime, int delayedTime) {
+        int newTime = arrivalTime + delayedTime;
+        return newTime - (newTime >= 24 ? 24 : 0);
+    }
+}

From 2e0f4ff134aceb372482c1382790b1b9c405468c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 23 Apr 2023 06:56:58 -0700
Subject: [PATCH 1635/2175] Added Sum Multiples.java

---
 Medium/Sum Multiples.java | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Medium/Sum Multiples.java

diff --git a/Medium/Sum Multiples.java b/Medium/Sum Multiples.java
new file mode 100644
index 00000000..59bfa012
--- /dev/null
+++ b/Medium/Sum Multiples.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int sumOfMultiples(int n) {
+        return IntStream.rangeClosed(1, n)
+                .filter(value -> value % 3 == 0 || value % 5 == 0 || value % 7 == 0)
+                .sum();
+    }
+}

From 9172a003269d65343caa90f3be7a5d10ba74a8f9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 23 Apr 2023 17:36:37 -0700
Subject: [PATCH 1636/2175] Updated Last Stone Weight.java

---
 Easy/Last Stone Weight.java | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/Easy/Last Stone Weight.java b/Easy/Last Stone Weight.java
index 08f390b1..afb35b41 100644
--- a/Easy/Last Stone Weight.java	
+++ b/Easy/Last Stone Weight.java	
@@ -1,16 +1,16 @@
 class Solution {
-  public int lastStoneWeight(int[] stones) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> o2 - o1);
-    for (int stone : stones) {
-      pq.add(stone);
+    public int lastStoneWeight(int[] stones) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        for (int stone : stones) {
+            pq.add(stone);
+        }
+        while (pq.size() > 1) {
+            int stoneOne = pq.poll();
+            int stoneTwo = pq.poll();
+            if (stoneOne != stoneTwo) {
+                pq.add(stoneOne - stoneTwo);
+            }
+        }
+        return pq.isEmpty() ? 0 : pq.poll();
     }
-    while (pq.size() > 1) {
-      int firstStone = pq.poll();
-      int secondStone = pq.poll();
-      if (firstStone != secondStone) {
-        pq.add(firstStone - secondStone);
-      }
-    }
-    return pq.isEmpty() ? 0 : pq.poll();
-  }
 }

From ea4c113b8c98bdbb0310e2ae11f03a9e3a447451 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 24 Apr 2023 12:32:55 -0700
Subject: [PATCH 1637/2175] Updated Sliding Window Maximum.java

---
 Hard/Sliding Window Maximum.java | 43 +++++++++++++++++---------------
 1 file changed, 23 insertions(+), 20 deletions(-)

diff --git a/Hard/Sliding Window Maximum.java b/Hard/Sliding Window Maximum.java
index c1ae146e..2aafc22d 100644
--- a/Hard/Sliding Window Maximum.java	
+++ b/Hard/Sliding Window Maximum.java	
@@ -1,23 +1,26 @@
 class Solution {
-  public int[] maxSlidingWindow(int[] nums, int k) {
-    int n = nums.length;
-    if (n == 0 || k == 0) {
-      return new int[0];
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        int[] result = new int[nums.length - k + 1];
+        int start = 0;
+        int end = 0;
+        Deque<Integer> queue = new ArrayDeque<>();
+        while (end < nums.length) {
+            // Remove elements from end of  queue as long as the value at end of queue is less
+            // than the current value
+            while (!queue.isEmpty() && nums[queue.peekLast()] < nums[end]) {
+                queue.removeLast();
+            }
+            queue.add(end);
+            // Remove the first element from the queue if we have already passed it in our range
+            if (start > queue.peekFirst()) {
+                queue.removeFirst();
+            }
+            // Update result if our window is at least of size k
+            if (end + 1 >= k) {
+                result[start++] = nums[queue.peekFirst()];
+            }
+            end++;
+        }
+        return result;
     }
-    int[] result = new int[n - k + 1];
-    Deque<Integer> deque = new ArrayDeque<>();
-    for (int i = 0; i < n; i++) {
-      while (deque.size() > 0 && deque.peekFirst() <= i - k) {
-        deque.pollFirst();
-      }
-      while (deque.size() > 0 && nums[deque.peekLast()] < nums[i]) {
-        deque.pollLast();
-      }
-      deque.offerLast(i);
-      if (i >= k - 1) {
-        result[i -k + 1] = nums[deque.peekFirst()];
-      }
-    }
-    return result;
-  }
 }

From 48835931330cdefe460f8c8685c0a0d61384c4bc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 24 Apr 2023 13:10:01 -0700
Subject: [PATCH 1638/2175] Updated Next Permutation.java

---
 Medium/Next Permutation.java | 54 ++++++++++++++++++------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/Medium/Next Permutation.java b/Medium/Next Permutation.java
index 7b808969..b08a0001 100644
--- a/Medium/Next Permutation.java	
+++ b/Medium/Next Permutation.java	
@@ -1,31 +1,31 @@
 class Solution {
-  public void nextPermutation(int[] nums) {
-    int idx = nums.length - 2;
-    while (idx >= 0 && nums[idx + 1] <= nums[idx]) {
-      idx--;
+    public void nextPermutation(int[] nums) {
+        int n = nums.length;
+        int pivot = n - 1;
+        // Find the first value where decreasing order doesn't holds
+        while (pivot > 0 && nums[pivot] <= nums[pivot - 1]) {
+            pivot--;
+        }
+        if (pivot != 0) {
+            int i = n - 1;
+            // Find the first value from right to left which is greater than element at
+            // pivot - 1
+            while (nums[i] <= nums[pivot - 1]) {
+                i--;
+            }
+            swap(nums, pivot - 1, i);
+        }
+        // Reverse the complete array
+        int left = pivot;
+        int right = n - 1;
+        while (left < right) {
+            swap(nums, left++, right--);
+        }
     }
-    if (idx >= 0) {
-      int endIdx = nums.length - 1;
-      while (nums[endIdx] <= nums[idx]) {
-        endIdx--;
-      }
-      swap(nums, idx, endIdx);
+
+    private void swap(int[] nums, int idxOne, int idxTwo) {
+        int temp = nums[idxOne];
+        nums[idxOne] = nums[idxTwo];
+        nums[idxTwo] = temp;
     }
-    reverse(nums, idx + 1);
-  }
-  
-  private void reverse(int[] nums, int startIdx) {
-    int endIdx = nums.length - 1;
-    while (startIdx < endIdx) {
-      swap(nums, startIdx, endIdx);
-      startIdx++;
-      endIdx--;
-    }
-  }
-  
-  private void swap(int[] nums, int i, int j) {
-    int temp = nums[i];
-    nums[i] = nums[j];
-    nums[j] = temp;
-  }
 }

From 12612219c07351b29034b86190f1eff6c828e424 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 24 Apr 2023 13:28:46 -0700
Subject: [PATCH 1639/2175] Updated Task Scheduler.java

---
 Medium/Task Scheduler.java | 40 +++++++++++++++++++++++++-------------
 1 file changed, 27 insertions(+), 13 deletions(-)

diff --git a/Medium/Task Scheduler.java b/Medium/Task Scheduler.java
index 558e1f77..0023aa9d 100644
--- a/Medium/Task Scheduler.java	
+++ b/Medium/Task Scheduler.java	
@@ -1,16 +1,30 @@
 class Solution {
-  public int leastInterval(char[] tasks, int n) {
-    int[] frequencies = new int[26];
-    for (char task : tasks) {
-      frequencies[task - 'A']++;
+    public int leastInterval(char[] tasks, int n) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : tasks) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        pq.addAll(map.values());
+        int cycles = 0;
+        while (!pq.isEmpty()) {
+            List<Integer> temp = new ArrayList<>();
+            // Wait for one cooldown period and process one occurrence of all remaining tasks
+            for (int i = 0; i < n + 1; i++) {
+                if (!pq.isEmpty()) {
+                    temp.add(pq.remove());
+                }
+            }
+            // If task has more occurrences left then add it back to heap
+            for (int task : temp) {
+                if (task > 1) {
+                    pq.add(task - 1);
+                }
+            }
+            // If heap is empty that means we finished all tasks and don't need to wait for 
+            // the whole cooldown to finish else add one complete cooldown period
+            cycles += pq.isEmpty() ? temp.size() : n + 1;
+        }
+        return cycles;
     }
-    Arrays.sort(frequencies);
-    int maxFrequency = frequencies[25];
-    int idleTime = (maxFrequency - 1) * n;
-    for (int i = frequencies.length - 2; i >= 0 && idleTime > 0; i--) {
-      idleTime -= Math.min(maxFrequency - 1, frequencies[i]);
-    }
-    idleTime = Math.max(0, idleTime);
-    return idleTime + tasks.length;
-  }
 }

From d9847ba15c92bfbe20e875e9447ec8d029361162 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 24 Apr 2023 14:26:46 -0700
Subject: [PATCH 1640/2175] Added Alien Dictionary.java

---
 Hard/Alien Dictionary.java | 48 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 Hard/Alien Dictionary.java

diff --git a/Hard/Alien Dictionary.java b/Hard/Alien Dictionary.java
new file mode 100644
index 00000000..939de634
--- /dev/null
+++ b/Hard/Alien Dictionary.java	
@@ -0,0 +1,48 @@
+class Solution {
+    public String alienOrder(String[] words) {
+        Map<Character, Set<Character>> graph = new HashMap<>();
+        for (String word : words) {
+            for (char c : word.toCharArray()) {
+                graph.computeIfAbsent(c, k -> new HashSet<>());
+            }
+        }
+        for (int i = 0; i < words.length - 1; i++) {
+            String word1 = words[i];
+            String word2 = words[i + 1];
+            int minLength = Math.min(word1.length(), word2.length());
+            if (word1.length() > word2.length() && word1.startsWith(word2)) {
+                return "";
+            }
+            for (int j = 0; j < minLength; j++) {
+                if (word1.charAt(j) != word2.charAt(j)) {
+                    graph.get(word1.charAt(j)).add(word2.charAt(j));
+                    break;
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        Map<Character, Boolean> visited = new HashMap<>();
+        for (Character c : graph.keySet()) {
+            if (dfs(c, graph, sb, visited)) {
+                return "";
+            }
+        }
+        return sb.reverse().toString();
+    }
+
+    private boolean dfs(Character c, Map<Character, Set<Character>> graph, 
+                        StringBuilder sb, Map<Character, Boolean> visited) {
+        if (visited.containsKey(c)) {
+            return visited.get(c);
+        }
+        visited.put(c, true);
+        for (Character neighbor : graph.getOrDefault(c, new HashSet<>())) {
+            if (dfs(neighbor, graph, sb, visited)) {
+                return true;
+            }
+        }
+        visited.put(c, false);
+        sb.append(c);
+        return false;
+    }
+}

From 86947527a7e06fe4c34a556fc2d2a3365647cfa3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 27 Apr 2023 06:49:48 -0700
Subject: [PATCH 1641/2175] Updated Minimum Window Subsequence.java

---
 Hard/Minimum Window Subsequence.java | 58 ++++++++++++++++------------
 1 file changed, 34 insertions(+), 24 deletions(-)

diff --git a/Hard/Minimum Window Subsequence.java b/Hard/Minimum Window Subsequence.java
index 88c2a006..d1a9b971 100644
--- a/Hard/Minimum Window Subsequence.java	
+++ b/Hard/Minimum Window Subsequence.java	
@@ -1,29 +1,39 @@
 class Solution {
-  public String minWindow(String s1, String s2) {
-    String window = "";
-    int j = 0;
-    int minLength = s1.length() + 1;
-    for (int i = 0; i < s1.length(); i++) {
-      if (s1.charAt(i) == s2.charAt(j)) {
-        j++;
-        if (j == s2.length()) {
-          int end = i + 1;
-          j--;
-          while (j >= 0) {
-            if (s1.charAt(i) == s2.charAt(j)) {
-              j--;
+    public String minWindow(String s1, String s2) {
+        int right = 0;
+        int minWindowLength = Integer.MAX_VALUE;
+        String result = "";
+        while (right < s1.length()) {
+            int s2Idx = 0;
+            while (right < s1.length()) {
+                if (s1.charAt(right) == s2.charAt(s2Idx)) {
+                    s2Idx++;
+                }
+                if (s2Idx == s2.length()) {
+                    break;
+                }
+                right++;
             }
-            i--;
-          }
-          j++;
-          i++;
-          if (end - i < minLength) {
-            minLength = end - i;
-            window = s1.substring(i, end);
-          }
+            if (right == s1.length()) {
+                break;
+            }
+            int s1EndIdx = right;
+            int s2EndIdx = s2.length() - 1;
+            while (s1EndIdx >= 0) {
+                if (s1.charAt(s1EndIdx) == s2.charAt(s2EndIdx)) {
+                    s2EndIdx--;
+                }
+                if (s2EndIdx < 0) {
+                    break;
+                }
+                s1EndIdx--;
+            }
+            if (right - s1EndIdx + 1 < minWindowLength) {
+                minWindowLength = right - s1EndIdx + 1;
+                result = s1.substring(s1EndIdx, right + 1);
+            }
+            right = s1EndIdx + 1;
         }
-      }
+        return result;
     }
-    return window;
-  }
 }

From 82b09798ab699ee6781d5f0e9fa55513a8a0942a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 27 Apr 2023 18:09:01 -0700
Subject: [PATCH 1642/2175] Added Similar String Groups.java

---
 Hard/Similar String Groups.java | 51 +++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 Hard/Similar String Groups.java

diff --git a/Hard/Similar String Groups.java b/Hard/Similar String Groups.java
new file mode 100644
index 00000000..50eb13d2
--- /dev/null
+++ b/Hard/Similar String Groups.java	
@@ -0,0 +1,51 @@
+class Solution {
+    public int numSimilarGroups(String[] strs) {
+        int n = strs.length;
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (isSimilar(strs[i], strs[j])) {
+                    graph.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
+                    graph.computeIfAbsent(j, k -> new ArrayList<>()).add(i);
+                }
+            }
+        }
+        boolean[] visited = new boolean[n];
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                bfs(i, graph, visited);
+                count++;
+            }
+        }
+        return count;
+    }
+    
+    private boolean isSimilar(String s1, String s2) {
+        int diff = 0;
+        for (int i = 0; i < s1.length(); i++) {
+            if (s1.charAt(i) != s2.charAt(i)) {
+                diff++;
+            }
+        }
+        return diff == 0 || diff == 2;
+    }
+    
+    private void bfs(int node, Map<Integer, List<Integer>> graph, boolean[] visited) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(node);
+        visited[node] = true;
+        while (!queue.isEmpty()) {
+            node = queue.poll();
+            if (!graph.containsKey(node)) {
+                continue;
+            }
+            for (int neighbor : graph.get(node)) {
+                if (!visited[neighbor]) {
+                    visited[neighbor] = true;
+                    queue.add(neighbor);
+                }
+            }
+        }
+    }
+}

From 23d28abb51e5417318918d1b10bfbd8aab3f59d8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 29 Apr 2023 07:32:47 -0700
Subject: [PATCH 1643/2175] Added Checking Existence of Edge Length Limited
 Paths.java

---
 ...xistence of Edge Length Limited Paths.java | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Hard/Checking Existence of Edge Length Limited Paths.java

diff --git a/Hard/Checking Existence of Edge Length Limited Paths.java b/Hard/Checking Existence of Edge Length Limited Paths.java
new file mode 100644
index 00000000..d03848ef
--- /dev/null
+++ b/Hard/Checking Existence of Edge Length Limited Paths.java	
@@ -0,0 +1,41 @@
+class Solution {
+    public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) {
+        UnionFind unionFind = new UnionFind(n);
+        for (int i = 0; i < queries.length; i++) {
+            queries[i] = new int[]{queries[i][0], queries[i][1], queries[i][2], i};
+        }
+        Arrays.sort(queries, Comparator.comparingInt(a -> a[2]));
+        Arrays.sort(edgeList, Comparator.comparingInt(a -> a[2]));
+        boolean[] result = new boolean[queries.length];
+        for (int i = 0, j = 0; i < queries.length; i++) {
+            int[] query = queries[i];
+            while (j < edgeList.length && edgeList[j][2] < query[2]) {
+                unionFind.union(edgeList[j][0], edgeList[j++][1]);
+            }
+            result[query[3]] = unionFind.find(query[0]) == unionFind.find(query[1]);
+        }
+        return result;
+    }
+    
+    private static class UnionFind {
+        private final int[] parent;
+        
+        public UnionFind(int n) {
+            this.parent = new int[n];
+            for (int i = 0; i < n; i++) {
+                parent[i] = i;
+            }
+        }
+        
+        public int find(int node) {
+            if (parent[node] != node) {
+                parent[node] = find(parent[node]);
+            }
+            return parent[node];
+        }
+        
+        public void union(int x, int y) {
+            parent[find(x)] = parent[find(y)];
+        }
+    }
+}

From 0b1e882294cac31192762809e1c1c723d6475416 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 29 Apr 2023 10:25:32 -0700
Subject: [PATCH 1644/2175] Added Maximum Sum With Exactly K Elements.java

---
 Easy/Maximum Sum With Exactly K Elements.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Maximum Sum With Exactly K Elements.java

diff --git a/Easy/Maximum Sum With Exactly K Elements.java b/Easy/Maximum Sum With Exactly K Elements.java
new file mode 100644
index 00000000..ad738207
--- /dev/null
+++ b/Easy/Maximum Sum With Exactly K Elements.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int maximizeSum(int[] nums, int k) {
+        int maxNum = 0;
+        for (int num : nums) {
+            maxNum = Math.max(num, maxNum);
+        }
+        int score = 0;
+        while (k-- > 0) {
+            score += maxNum++;
+        }
+        return score;
+    }
+}

From ece65cc705adc2f8c63839d22f8e29d26941b85f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 29 Apr 2023 10:28:31 -0700
Subject: [PATCH 1645/2175] Updated stats

---
 Easy/README.md   | 1057 +++++++++++++++++----------------
 Hard/README.md   |  205 ++++---
 Medium/README.md | 1483 +++++++++++++++++++++++-----------------------
 README.md        |    8 +-
 4 files changed, 1393 insertions(+), 1360 deletions(-)

diff --git a/Easy/README.md b/Easy/README.md
index 23f8ec11..d3b1e72e 100644
--- a/Easy/README.md
+++ b/Easy/README.md
@@ -39,527 +39,536 @@ S.no | Coding Problem
 36 | [Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java)
 37 | [Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java)
 38 | [Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java)
-39 | [Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java)
-40 | [Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
-41 | [Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
-42 | [Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
-43 | [Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java)
-44 | [Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java)
-45 | [Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java)
-46 | [Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
-47 | [Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
-48 | [Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java)
-49 | [Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
-50 | [Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
-51 | [Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
-52 | [Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
-53 | [Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
-54 | [Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
-55 | [Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java)
-56 | [Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java)
-57 | [Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
-58 | [Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
-59 | [Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
-60 | [Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
-61 | [Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java)
-62 | [Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java)
-63 | [Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java)
-64 | [Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java)
-65 | [Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
-66 | [Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java)
-67 | [Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
-68 | [Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java)
-69 | [Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
-70 | [Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java)
-71 | [Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
-72 | [Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
-73 | [Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
-74 | [Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
-75 | [Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
-76 | [Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
-77 | [Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
-78 | [Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
-79 | [Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
-80 | [Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
-81 | [Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java)
-82 | [Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java)
-83 | [Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
-84 | [Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
-85 | [Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
-86 | [Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
-87 | [Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java)
-88 | [Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java)
-89 | [Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
-90 | [Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java)
-91 | [Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java)
-92 | [Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java)
-93 | [Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java)
-94 | [Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
-95 | [Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java)
-96 | [Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java)
-97 | [Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
-98 | [Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
-99 | [Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
-100 | [Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java)
-101 | [Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
-102 | [Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java)
-103 | [Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java)
-104 | [Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java)
-105 | [Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
-106 | [Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java)
-107 | [Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
-108 | [Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
-109 | [Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java)
-110 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
-111 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java)
-112 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
-113 | [Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java)
-114 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java)
-115 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
-116 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java)
-117 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
-118 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
-119 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
-120 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
-121 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
-122 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
-123 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
-124 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java)
-125 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
-126 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
-127 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
-128 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
-129 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
-130 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
-131 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
-132 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
-133 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java)
-134 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
-135 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
-136 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
-137 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
-138 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
-139 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java)
-140 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
-141 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
-142 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
-143 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
-144 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
-145 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
-146 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
-147 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java)
-148 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
-149 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
-150 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java)
-151 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
-152 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
-153 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
-154 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java)
-155 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java)
-156 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
-157 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
-158 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
-159 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
-160 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java)
-161 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
-162 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
-163 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
-164 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
-165 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java)
-166 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
-167 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java)
-168 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java)
-169 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
-170 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
-171 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
-172 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java)
-173 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
-174 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java)
-175 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
-176 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
-177 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
-178 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
-179 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
-180 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
-181 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
-182 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
-183 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java)
-184 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
-185 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java)
-186 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java)
-187 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
-188 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
-189 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java)
-190 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java)
-191 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java)
-192 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
-193 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
-194 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java)
-195 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java)
-196 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
-197 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
-198 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java)
-199 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
-200 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java)
-201 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
-202 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
-203 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
-204 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
-205 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
-206 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
-207 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
-208 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
-209 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
-210 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
-211 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
-212 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
-213 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java)
-214 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
-215 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
-216 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
-217 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
-218 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
-219 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
-220 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
-221 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
-222 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
-223 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
-224 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
-225 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
-226 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
-227 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
-228 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
-229 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
-230 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
-231 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java)
-232 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
-233 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java)
-234 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
-235 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
-236 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
-237 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
-238 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
-239 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
-240 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
-241 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
-242 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
-243 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java)
-244 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
-245 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
-246 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java)
-247 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
-248 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
-249 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java)
-250 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java)
-251 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java)
-252 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
-253 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
-254 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
-255 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java)
-256 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
-257 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
-258 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
-259 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
-260 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
-261 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
-262 | [Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java)
-263 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
-264 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
-265 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
-266 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
-267 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
-268 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
-269 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
-270 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
-271 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
-272 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
-273 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
-274 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
-275 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
-276 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java)
-277 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
-278 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
-279 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
-280 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
-281 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
-282 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
-283 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
-284 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java)
-285 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
-286 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
-287 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
-288 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
-289 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java)
-290 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
-291 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
-292 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
-293 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java)
-294 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
-295 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java)
-296 | [Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java)
-297 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
-298 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java)
-299 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
-300 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
-301 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
-302 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java)
-303 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java)
-304 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
-305 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
-306 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
-307 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java)
-308 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
-309 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
-310 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
-311 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
-312 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java)
-313 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
-314 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
-315 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
-316 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java)
-317 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
-318 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
-319 | [Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java)
-320 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
-321 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
-322 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
-323 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
-324 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java)
-325 | [Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
-326 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
-327 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java)
-328 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java)
-329 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
-330 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java)
-331 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java)
-332 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java)
-333 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java)
-334 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
-335 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
-336 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
-337 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
-338 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java)
-339 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
-340 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java)
-341 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
-342 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java)
-343 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java)
-344 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
-345 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java)
-346 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
-347 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java)
-348 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
-349 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
-350 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
-351 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
-352 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
-353 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
-354 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java)
-355 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
-356 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
-357 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java)
-358 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java)
-359 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
-360 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
-361 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
-362 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
-363 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
-364 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
-365 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
-366 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
-367 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
-368 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
-369 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
-370 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
-371 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
-372 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
-373 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java)
-374 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
-375 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java)
-376 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
-377 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
-378 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
-379 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java)
-380 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
-381 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
-382 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
-383 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
-384 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
-385 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
-386 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
-387 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
-388 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java)
-389 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java)
-390 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
-391 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
-392 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java)
-393 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
-394 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
-395 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
-396 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
-397 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
-398 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
-399 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
-400 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
-401 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
-402 | [Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java)
-403 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
-404 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
-405 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
-406 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
-407 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java)
-408 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
-409 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
-410 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
-411 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
-412 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java)
-413 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
-414 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
-415 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
-416 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
-417 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
-418 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java)
-419 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
-420 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
-421 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
-422 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java)
-423 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
-424 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java)
-425 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
-426 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
-427 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
-428 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
-429 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
-430 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
-431 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
-432 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java)
-433 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
-434 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
-435 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
-436 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java)
-437 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
-438 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
-439 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
-440 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java)
-441 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
-442 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
-443 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
-444 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
-445 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
-446 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
-447 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
-448 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
-449 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
-450 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
-451 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java)
-452 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
-453 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
-454 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
-455 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
-456 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
-457 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java)
-458 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
-459 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
-460 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java)
-461 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
-462 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
-463 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
-464 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
-465 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
-466 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
-467 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
-468 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
-469 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
-470 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java)
-471 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
-472 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
-473 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java)
-474 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
-475 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
-476 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
-477 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
-478 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
-479 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java)
-480 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
-481 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
-482 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
-483 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java)
-484 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java)
-485 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
-486 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
-487 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
-488 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
-489 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java)
-490 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
-491 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java)
-492 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
-493 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
-494 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
-495 | [Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java)
-496 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
-497 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
-498 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
-499 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
-500 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
-501 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
-502 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java)
-503 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
-504 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
-505 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
-506 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
-507 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
-508 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java)
-509 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
-510 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
-511 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
-512 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
-513 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java)
-514 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
-515 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
-516 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
-517 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
-518 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
-519 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java)
-520 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java)
-521 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
-522 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java)
-523 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
-524 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
-525 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
-526 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
-527 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
-528 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java)
-529 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
-530 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
-531 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
-532 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
-533 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java)
-534 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java)
-535 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
-536 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
-537 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
-538 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
-539 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
-540 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
-541 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
-542 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
-543 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
-544 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
-545 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
-546 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
-547 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
-548 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
-549 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
-550 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
-551 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
-552 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java)
-553 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
-554 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java)
-555 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
-556 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
-557 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
-558 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
-559 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java)
-560 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
-561 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
-562 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
+39 | [Calculate Delayed Arrival Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Delayed%20Arrival%20Time.java)
+40 | [Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java)
+41 | [Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
+42 | [Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
+43 | [Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
+44 | [Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java)
+45 | [Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java)
+46 | [Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java)
+47 | [Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
+48 | [Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
+49 | [Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java)
+50 | [Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
+51 | [Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
+52 | [Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
+53 | [Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
+54 | [Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
+55 | [Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
+56 | [Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java)
+57 | [Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java)
+58 | [Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
+59 | [Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
+60 | [Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
+61 | [Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
+62 | [Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java)
+63 | [Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java)
+64 | [Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java)
+65 | [Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java)
+66 | [Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
+67 | [Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java)
+68 | [Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
+69 | [Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java)
+70 | [Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
+71 | [Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java)
+72 | [Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
+73 | [Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
+74 | [Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
+75 | [Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
+76 | [Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
+77 | [Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
+78 | [Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
+79 | [Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
+80 | [Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
+81 | [Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
+82 | [Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java)
+83 | [Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java)
+84 | [Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
+85 | [Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
+86 | [Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
+87 | [Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
+88 | [Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java)
+89 | [Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java)
+90 | [Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
+91 | [Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java)
+92 | [Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java)
+93 | [Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java)
+94 | [Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java)
+95 | [Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
+96 | [Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java)
+97 | [Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java)
+98 | [Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
+99 | [Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
+100 | [Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
+101 | [Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java)
+102 | [Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
+103 | [Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java)
+104 | [Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java)
+105 | [Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java)
+106 | [Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
+107 | [Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java)
+108 | [Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
+109 | [Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
+110 | [Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java)
+111 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
+112 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java)
+113 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
+114 | [Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java)
+115 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java)
+116 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
+117 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java)
+118 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
+119 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
+120 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
+121 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
+122 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
+123 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
+124 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
+125 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java)
+126 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
+127 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
+128 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
+129 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
+130 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
+131 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
+132 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
+133 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
+134 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java)
+135 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
+136 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
+137 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
+138 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
+139 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
+140 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java)
+141 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
+142 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
+143 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
+144 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
+145 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
+146 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
+147 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
+148 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java)
+149 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
+150 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
+151 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java)
+152 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
+153 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
+154 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
+155 | [Distribute Money to Maximum Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Money%20to%20Maximum%20Children.java)
+156 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java)
+157 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java)
+158 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
+159 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
+160 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
+161 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
+162 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java)
+163 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
+164 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
+165 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
+166 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
+167 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java)
+168 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
+169 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java)
+170 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java)
+171 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
+172 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
+173 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
+174 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java)
+175 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
+176 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java)
+177 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
+178 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
+179 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
+180 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
+181 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
+182 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
+183 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
+184 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
+185 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java)
+186 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
+187 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java)
+188 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java)
+189 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
+190 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
+191 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java)
+192 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java)
+193 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java)
+194 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
+195 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
+196 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java)
+197 | [Find the Longest Balanced Substring of a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Longest%20Balanced%20Substring%20of%20a%20Binary%20String.java)
+198 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java)
+199 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
+200 | [Find the Width of Columns of a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Width%20of%20Columns%20of%20a%20Grid.java)
+201 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
+202 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java)
+203 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
+204 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java)
+205 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
+206 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
+207 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
+208 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
+209 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
+210 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
+211 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
+212 | [Form Smallest Number From Two Digit Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Form%20Smallest%20Number%20From%20Two%20Digit%20Arrays.java)
+213 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
+214 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
+215 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
+216 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
+217 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
+218 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java)
+219 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
+220 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
+221 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
+222 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
+223 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
+224 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
+225 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
+226 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
+227 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
+228 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
+229 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
+230 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
+231 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
+232 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
+233 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
+234 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
+235 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
+236 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java)
+237 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
+238 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java)
+239 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
+240 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
+241 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
+242 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
+243 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
+244 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
+245 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
+246 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
+247 | [K Items With the Maximum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Items%20With%20the%20Maximum%20Sum.java)
+248 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
+249 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java)
+250 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
+251 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
+252 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java)
+253 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
+254 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
+255 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java)
+256 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java)
+257 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java)
+258 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
+259 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
+260 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
+261 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java)
+262 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
+263 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
+264 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
+265 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
+266 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
+267 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
+268 | [Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java)
+269 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
+270 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
+271 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
+272 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
+273 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
+274 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
+275 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
+276 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
+277 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
+278 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
+279 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
+280 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
+281 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
+282 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java)
+283 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
+284 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
+285 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
+286 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
+287 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
+288 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
+289 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
+290 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java)
+291 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
+292 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
+293 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
+294 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
+295 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java)
+296 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
+297 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
+298 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
+299 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java)
+300 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
+301 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java)
+302 | [Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java)
+303 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
+304 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java)
+305 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
+306 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
+307 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
+308 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java)
+309 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java)
+310 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
+311 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
+312 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
+313 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java)
+314 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
+315 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
+316 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
+317 | [Maximum Sum With Exactly K Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Sum%20With%20Exactly%20K%20Elements.java)
+318 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
+319 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java)
+320 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
+321 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
+322 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
+323 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java)
+324 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
+325 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
+326 | [Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java)
+327 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
+328 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
+329 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
+330 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
+331 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java)
+332 | [Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
+333 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
+334 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java)
+335 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java)
+336 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
+337 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java)
+338 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java)
+339 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java)
+340 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java)
+341 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
+342 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
+343 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
+344 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
+345 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java)
+346 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
+347 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java)
+348 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
+349 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java)
+350 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java)
+351 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
+352 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java)
+353 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
+354 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java)
+355 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
+356 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
+357 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
+358 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
+359 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
+360 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
+361 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java)
+362 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
+363 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
+364 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java)
+365 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java)
+366 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
+367 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
+368 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
+369 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
+370 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
+371 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
+372 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
+373 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
+374 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
+375 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
+376 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
+377 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
+378 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
+379 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
+380 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java)
+381 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
+382 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java)
+383 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
+384 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
+385 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
+386 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java)
+387 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
+388 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
+389 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
+390 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
+391 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
+392 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
+393 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
+394 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
+395 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java)
+396 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java)
+397 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
+398 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
+399 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java)
+400 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
+401 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
+402 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
+403 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
+404 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
+405 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
+406 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
+407 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
+408 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
+409 | [Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java)
+410 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
+411 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
+412 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
+413 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
+414 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java)
+415 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
+416 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
+417 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
+418 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
+419 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java)
+420 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
+421 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
+422 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
+423 | [Prime In Diagonal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Prime%20In%20Diagonal.java)
+424 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
+425 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
+426 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java)
+427 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
+428 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
+429 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
+430 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java)
+431 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
+432 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java)
+433 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
+434 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
+435 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
+436 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
+437 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
+438 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
+439 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
+440 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java)
+441 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
+442 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
+443 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
+444 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java)
+445 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
+446 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
+447 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
+448 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java)
+449 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
+450 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
+451 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
+452 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
+453 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
+454 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
+455 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
+456 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
+457 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
+458 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
+459 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java)
+460 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
+461 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
+462 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
+463 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
+464 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
+465 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java)
+466 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
+467 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
+468 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java)
+469 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
+470 | [Row With Maximum Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Row%20With%20Maximum%20Ones.java)
+471 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
+472 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
+473 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
+474 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
+475 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
+476 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
+477 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
+478 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
+479 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java)
+480 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
+481 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
+482 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java)
+483 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
+484 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
+485 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
+486 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
+487 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
+488 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java)
+489 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
+490 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
+491 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
+492 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java)
+493 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java)
+494 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
+495 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
+496 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
+497 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
+498 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java)
+499 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
+500 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java)
+501 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
+502 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
+503 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
+504 | [Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java)
+505 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
+506 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
+507 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
+508 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
+509 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
+510 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
+511 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java)
+512 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
+513 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
+514 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
+515 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
+516 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
+517 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java)
+518 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
+519 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
+520 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
+521 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
+522 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java)
+523 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
+524 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
+525 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
+526 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
+527 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
+528 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java)
+529 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java)
+530 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
+531 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java)
+532 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
+533 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
+534 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
+535 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
+536 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
+537 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java)
+538 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
+539 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
+540 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
+541 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
+542 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java)
+543 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java)
+544 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
+545 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
+546 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
+547 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
+548 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
+549 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
+550 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
+551 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
+552 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
+553 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
+554 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
+555 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
+556 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
+557 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
+558 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
+559 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
+560 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
+561 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java)
+562 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
+563 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java)
+564 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
+565 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
+566 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
+567 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
+568 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java)
+569 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
+570 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
+571 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
diff --git a/Hard/README.md b/Hard/README.md
index 3ada6cad..e97d573a 100644
--- a/Hard/README.md
+++ b/Hard/README.md
@@ -2,99 +2,112 @@
 S.no | Coding Problem 
 --- | --- 
 1 | [Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java)
-2 | [Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
-3 | [Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
-4 | [Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java)
-5 | [Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java)
-6 | [Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
-7 | [Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
-8 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
-9 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
-10 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java)
-11 | [Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java)
-12 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java)
-13 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java)
-14 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java)
-15 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java)
-16 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
-17 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java)
-18 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java)
-19 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
-20 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java)
-21 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java)
-22 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
-23 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
-24 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
-25 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java)
-26 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java)
-27 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
-28 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java)
-29 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
-30 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
-31 | [IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java)
-32 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
-33 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
-34 | [Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java)
-35 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
-36 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java)
-37 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java)
-38 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
-39 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
-40 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
-41 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
-42 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java)
-43 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java)
-44 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java)
-45 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
-46 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
-47 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java)
-48 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java)
-49 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
-50 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
-51 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
-52 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
-53 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
-54 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java)
-55 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java)
-56 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java)
-57 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
-58 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java)
-59 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java)
-60 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
-61 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java)
-62 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
-63 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
-64 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
-65 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
-66 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
-67 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
-68 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java)
-69 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
-70 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
-71 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java)
-72 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java)
-73 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
-74 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java)
-75 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
-76 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
-77 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
-78 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
-79 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
-80 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
-81 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
-82 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
-83 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
-84 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java)
-85 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
-86 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java)
-87 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
-88 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
-89 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
-90 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java)
-91 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
-92 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
-93 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
-94 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java)
-95 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java)
-96 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
-97 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
+2 | [Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Alien%20Dictionary.java)
+3 | [Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
+4 | [Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
+5 | [Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java)
+6 | [Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java)
+7 | [Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
+8 | [Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
+9 | [Checking Existence of Edge Length Limited Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Checking%20Existence%20of%20Edge%20Length%20Limited%20Paths.java)
+10 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
+11 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
+12 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java)
+13 | [Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java)
+14 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java)
+15 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java)
+16 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java)
+17 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java)
+18 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
+19 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java)
+20 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java)
+21 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
+22 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java)
+23 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java)
+24 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
+25 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
+26 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
+27 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java)
+28 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java)
+29 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
+30 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java)
+31 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
+32 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
+33 | [IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java)
+34 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
+35 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
+36 | [Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java)
+37 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
+38 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java)
+39 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java)
+40 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
+41 | [Largest Color Value in a Directed Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Color%20Value%20in%20a%20Directed%20Graph.java)
+42 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
+43 | [Longest Cycle in a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Cycle%20in%20a%20Graph.java)
+44 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
+45 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
+46 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java)
+47 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java)
+48 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java)
+49 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
+50 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
+51 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java)
+52 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java)
+53 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
+54 | [Maximum Value of K Coins From Piles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Value%20of%20K%20Coins%20From%20Piles.java)
+55 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
+56 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
+57 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
+58 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
+59 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java)
+60 | [Minimum Insertion Steps to Make a String Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Insertion%20Steps%20to%20Make%20a%20String%20Palindrome.java)
+61 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java)
+62 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java)
+63 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
+64 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java)
+65 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java)
+66 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
+67 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java)
+68 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
+69 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
+70 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
+71 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
+72 | [Number of Ways of Cutting a Pizza](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20of%20Cutting%20a%20Pizza.java)
+73 | [Number of Ways to Form a Target String Given a Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Form%20a%20Target%20String%20Given%20a%20Dictionary.java)
+74 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
+75 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
+76 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java)
+77 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
+78 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
+79 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java)
+80 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java)
+81 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
+82 | [Profitable Schemes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Profitable%20Schemes.java)
+83 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java)
+84 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
+85 | [Reducing Dishes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reducing%20Dishes.java)
+86 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
+87 | [Restore The Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Restore%20The%20Array.java)
+88 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
+89 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
+90 | [Scramble String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Scramble%20String.java)
+91 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
+92 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
+93 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
+94 | [Similar String Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Similar%20String%20Groups.java)
+95 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
+96 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
+97 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java)
+98 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
+99 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java)
+100 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
+101 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
+102 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
+103 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java)
+104 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
+105 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
+106 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
+107 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java)
+108 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java)
+109 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
+110 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
diff --git a/Medium/README.md b/Medium/README.md
index cea9747e..0d6a9299 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -7,739 +7,750 @@ S.no | Coding Problem
 4 | [3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
 5 | [3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java)
 6 | [3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
-7 | [4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
-8 | [4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
-9 | [4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
-10 | [Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
-11 | [Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
-12 | [Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
-13 | [Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
-14 | [Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
-15 | [Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
-16 | [Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java)
-17 | [Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
-18 | [Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
-19 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
-20 | [All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java)
-21 | [All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java)
-22 | [All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
-23 | [All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
-24 | [All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
-25 | [All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
-26 | [All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
-27 | [Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
-28 | [Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
-29 | [Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java)
-30 | [Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java)
-31 | [Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
-32 | [Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java)
-33 | [Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
-34 | [Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
-35 | [Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
-36 | [Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
-37 | [As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
-38 | [Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
-39 | [Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
-40 | [Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java)
-41 | [Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java)
-42 | [Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
-43 | [Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
-44 | [Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java)
-45 | [Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
-46 | [Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java)
-47 | [Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
-48 | [Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
-49 | [Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
-50 | [Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java)
-51 | [Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
-52 | [Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
-53 | [Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
-54 | [Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
-55 | [Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
-56 | [Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
-57 | [Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
-58 | [Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
-59 | [Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java)
-60 | [Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
-61 | [Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
-62 | [Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java)
-63 | [Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java)
-64 | [Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
-65 | [Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java)
-66 | [Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
-67 | [Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
-68 | [Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java)
-69 | [Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
-70 | [Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
-71 | [Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
-72 | [Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
-73 | [Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
-74 | [Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
-75 | [Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
-76 | [Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
-77 | [Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
-78 | [Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
-79 | [Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java)
-80 | [Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
-81 | [Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
-82 | [Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
-83 | [Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
-84 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
-85 | [Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
-86 | [Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
-87 | [Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
-88 | [Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
-89 | [Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
-90 | [Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java)
-91 | [Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
-92 | [Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
-93 | [Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
-94 | [Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
-95 | [Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java)
-96 | [Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
-97 | [Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
-98 | [Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
-99 | [Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
-100 | [Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
-101 | [Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java)
-102 | [Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java)
-103 | [Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
-104 | [Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
-105 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java)
-106 | [Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
-107 | [Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
-108 | [Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java)
-109 | [Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
-110 | [Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
-111 | [Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
-112 | [Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java)
-113 | [Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
-114 | [Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
-115 | [Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
-116 | [Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
-117 | [Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java)
-118 | [Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
-119 | [Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
-120 | [Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java)
-121 | [Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java)
-122 | [Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java)
-123 | [Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java)
-124 | [Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
-125 | [Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
-126 | [Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
-127 | [Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
-128 | [Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
-129 | [Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
-130 | [Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java)
-131 | [Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
-132 | [Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
-133 | [Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java)
-134 | [Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java)
-135 | [Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java)
-136 | [Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
-137 | [Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
-138 | [Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java)
-139 | [Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
-140 | [Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
-141 | [Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
-142 | [Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
-143 | [Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
-144 | [Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
-145 | [Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
-146 | [Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
-147 | [Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
-148 | [Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
-149 | [Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
-150 | [Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java)
-151 | [Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
-152 | [Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java)
-153 | [Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
-154 | [Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
-155 | [Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
-156 | [Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
-157 | [Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
-158 | [Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java)
-159 | [Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
-160 | [Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
-161 | [Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
-162 | [Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java)
-163 | [Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java)
-164 | [Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
-165 | [Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
-166 | [Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
-167 | [Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
-168 | [Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
-169 | [Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java)
-170 | [Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java)
-171 | [Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
-172 | [Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
-173 | [Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
-174 | [Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
-175 | [Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
-176 | [Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
-177 | [Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java)
-178 | [Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
-179 | [Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
-180 | [Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
-181 | [Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
-182 | [Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java)
-183 | [Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
-184 | [Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
-185 | [Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
-186 | [Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java)
-187 | [Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
-188 | [Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
-189 | [Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java)
-190 | [Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
-191 | [Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java)
-192 | [Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
-193 | [Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
-194 | [Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java)
-195 | [Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java)
-196 | [Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
-197 | [Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
-198 | [Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java)
-199 | [Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java)
-200 | [Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java)
-201 | [Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
-202 | [Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
-203 | [Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
-204 | [Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
-205 | [Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
-206 | [Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
-207 | [Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
-208 | [Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
-209 | [Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
-210 | [Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
-211 | [Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java)
-212 | [Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
-213 | [Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java)
-214 | [Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
-215 | [Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
-216 | [Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java)
-217 | [Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
-218 | [Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
-219 | [Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
-220 | [Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java)
-221 | [Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java)
-222 | [Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
-223 | [Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
-224 | [Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
-225 | [Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
-226 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
-227 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
-228 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java)
-229 | [Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java)
-230 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
-231 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
-232 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java)
-233 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
-234 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
-235 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
-236 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
-237 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
-238 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
-239 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
-240 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
-241 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
-242 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
-243 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
-244 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
-245 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java)
-246 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
-247 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java)
-248 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
-249 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
-250 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
-251 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
-252 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
-253 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
-254 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
-255 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
-256 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
-257 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
-258 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
-259 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
-260 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
-261 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
-262 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
-263 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
-264 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java)
-265 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java)
-266 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
-267 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
-268 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
-269 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java)
-270 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
-271 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
-272 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
-273 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
-274 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
-275 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
-276 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java)
-277 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
-278 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
-279 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
-280 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
-281 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
-282 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
-283 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java)
-284 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
-285 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
-286 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
-287 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
-288 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java)
-289 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java)
-290 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java)
-291 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
-292 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java)
-293 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java)
-294 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
-295 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
-296 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
-297 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
-298 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
-299 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
-300 | [Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java)
-301 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
-302 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
-303 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java)
-304 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
-305 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
-306 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
-307 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java)
-308 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
-309 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
-310 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
-311 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
-312 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java)
-313 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
-314 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
-315 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java)
-316 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java)
-317 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
-318 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
-319 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
-320 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
-321 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
-322 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
-323 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
-324 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
-325 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java)
-326 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
-327 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
-328 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java)
-329 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
-330 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
-331 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
-332 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
-333 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java)
-334 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
-335 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
-336 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
-337 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java)
-338 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
-339 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java)
-340 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
-341 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
-342 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
-343 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java)
-344 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
-345 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
-346 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
-347 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
-348 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
-349 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java)
-350 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java)
-351 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
-352 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
-353 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
-354 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
-355 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java)
-356 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
-357 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java)
-358 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
-359 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java)
-360 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java)
-361 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
-362 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java)
-363 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
-364 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java)
-365 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
-366 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
-367 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java)
-368 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
-369 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
-370 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
-371 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
-372 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
-373 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java)
-374 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
-375 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
-376 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java)
-377 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java)
-378 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java)
-379 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java)
-380 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java)
-381 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java)
-382 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
-383 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
-384 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
-385 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java)
-386 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
-387 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java)
-388 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java)
-389 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
-390 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java)
-391 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
-392 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java)
-393 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java)
-394 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java)
-395 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java)
-396 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java)
-397 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java)
-398 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java)
-399 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
-400 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
-401 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
-402 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
-403 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
-404 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
-405 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
-406 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
-407 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
-408 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java)
-409 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java)
-410 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java)
-411 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
-412 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
-413 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
-414 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java)
-415 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
-416 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java)
-417 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
-418 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java)
-419 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java)
-420 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
-421 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
-422 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java)
-423 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
-424 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
-425 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java)
-426 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java)
-427 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
-428 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java)
-429 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
-430 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
-431 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
-432 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java)
-433 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java)
-434 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
-435 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java)
-436 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
-437 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
-438 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
-439 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
-440 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
-441 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
-442 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java)
-443 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
-444 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
-445 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java)
-446 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
-447 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java)
-448 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java)
-449 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java)
-450 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java)
-451 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
-452 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
-453 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java)
-454 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java)
-455 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
-456 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
-457 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
-458 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
-459 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java)
-460 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java)
-461 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
-462 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
-463 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
-464 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
-465 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
-466 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
-467 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java)
-468 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
-469 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java)
-470 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
-471 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java)
-472 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
-473 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java)
-474 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
-475 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
-476 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
-477 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java)
-478 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java)
-479 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
-480 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java)
-481 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
-482 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
-483 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
-484 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
-485 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java)
-486 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java)
-487 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java)
-488 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java)
-489 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
-490 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
-491 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
-492 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
-493 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java)
-494 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java)
-495 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
-496 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
-497 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
-498 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java)
-499 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
-500 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
-501 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
-502 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
-503 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java)
-504 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java)
-505 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
-506 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java)
-507 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
-508 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
-509 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
-510 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java)
-511 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java)
-512 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java)
-513 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
-514 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
-515 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
-516 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
-517 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java)
-518 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
-519 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
-520 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
-521 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
-522 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
-523 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
-524 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
-525 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
-526 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
-527 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
-528 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
-529 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
-530 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
-531 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java)
-532 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
-533 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java)
-534 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
-535 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
-536 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
-537 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
-538 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
-539 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
-540 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
-541 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java)
-542 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
-543 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
-544 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java)
-545 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java)
-546 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
-547 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
-548 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
-549 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
-550 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
-551 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
-552 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
-553 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
-554 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
-555 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
-556 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
-557 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java)
-558 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java)
-559 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
-560 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java)
-561 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
-562 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
-563 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
-564 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
-565 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
-566 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java)
-567 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
-568 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
-569 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
-570 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
-571 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java)
-572 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
-573 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
-574 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
-575 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java)
-576 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
-577 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
-578 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
-579 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java)
-580 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java)
-581 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
-582 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
-583 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java)
-584 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
-585 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
-586 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java)
-587 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
-588 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
-589 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
-590 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java)
-591 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
-592 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java)
-593 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java)
-594 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
-595 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
-596 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
-597 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
-598 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
-599 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
-600 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
-601 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
-602 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java)
-603 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
-604 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java)
-605 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
-606 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
-607 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
-608 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
-609 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java)
-610 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
-611 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
-612 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
-613 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
-614 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
-615 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
-616 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
-617 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java)
-618 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
-619 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
-620 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
-621 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
-622 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
-623 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
-624 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java)
-625 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
-626 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
-627 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
-628 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java)
-629 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
-630 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
-631 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
-632 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
-633 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java)
-634 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
-635 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
-636 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
-637 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
-638 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
-639 | [Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java)
-640 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
-641 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
-642 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java)
-643 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
-644 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java)
-645 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
-646 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
-647 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
-648 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
-649 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
-650 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
-651 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java)
-652 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
-653 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
-654 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java)
-655 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
-656 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java)
-657 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
-658 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
-659 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
-660 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
-661 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
-662 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java)
-663 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
-664 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java)
-665 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java)
-666 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java)
-667 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java)
-668 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java)
-669 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
-670 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
-671 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
-672 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java)
-673 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
-674 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
-675 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
-676 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java)
-677 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
-678 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
-679 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java)
-680 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java)
-681 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
-682 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java)
-683 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java)
-684 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
-685 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
-686 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
-687 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
-688 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
-689 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java)
-690 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
-691 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
-692 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
-693 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
-694 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
-695 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java)
-696 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
-697 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
-698 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
-699 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
-700 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
-701 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java)
-702 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
-703 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
-704 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
-705 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java)
-706 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java)
-707 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
-708 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
-709 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java)
-710 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java)
-711 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
-712 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java)
-713 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java)
-714 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
-715 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
-716 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
-717 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
-718 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
-719 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
-720 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
-721 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
-722 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
-723 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
-724 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
-725 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
-726 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
-727 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
-728 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
-729 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
-730 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java)
-731 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
-732 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
-733 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java)
-734 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
-735 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
-736 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java)
-737 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
-738 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
-739 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
-740 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java)
-741 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
-742 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
+7 | [4 Keys Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Keys%20Keyboard.java)
+8 | [4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
+9 | [4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
+10 | [4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
+11 | [Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
+12 | [Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
+13 | [Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
+14 | [Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
+15 | [Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
+16 | [Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
+17 | [Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java)
+18 | [Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
+19 | [Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
+20 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
+21 | [All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java)
+22 | [All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java)
+23 | [All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
+24 | [All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
+25 | [All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
+26 | [All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
+27 | [All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
+28 | [Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
+29 | [Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
+30 | [Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java)
+31 | [Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java)
+32 | [Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
+33 | [Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java)
+34 | [Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
+35 | [Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
+36 | [Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
+37 | [Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
+38 | [As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
+39 | [Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
+40 | [Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
+41 | [Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java)
+42 | [Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java)
+43 | [Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
+44 | [Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
+45 | [Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java)
+46 | [Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
+47 | [Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java)
+48 | [Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
+49 | [Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
+50 | [Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
+51 | [Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java)
+52 | [Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
+53 | [Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
+54 | [Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
+55 | [Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
+56 | [Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
+57 | [Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
+58 | [Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
+59 | [Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
+60 | [Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java)
+61 | [Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
+62 | [Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
+63 | [Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java)
+64 | [Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java)
+65 | [Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
+66 | [Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java)
+67 | [Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
+68 | [Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
+69 | [Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java)
+70 | [Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
+71 | [Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
+72 | [Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
+73 | [Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
+74 | [Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
+75 | [Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
+76 | [Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
+77 | [Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
+78 | [Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
+79 | [Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
+80 | [Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java)
+81 | [Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
+82 | [Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
+83 | [Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
+84 | [Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
+85 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
+86 | [Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
+87 | [Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
+88 | [Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
+89 | [Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
+90 | [Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
+91 | [Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java)
+92 | [Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
+93 | [Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
+94 | [Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
+95 | [Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
+96 | [Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java)
+97 | [Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
+98 | [Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
+99 | [Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
+100 | [Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
+101 | [Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
+102 | [Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java)
+103 | [Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java)
+104 | [Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
+105 | [Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
+106 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java)
+107 | [Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
+108 | [Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
+109 | [Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java)
+110 | [Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
+111 | [Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
+112 | [Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
+113 | [Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java)
+114 | [Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
+115 | [Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
+116 | [Convert an Array Into a 2D Array With Conditions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20an%20Array%20Into%20a%202D%20Array%20With%20Conditions.java)
+117 | [Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
+118 | [Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
+119 | [Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java)
+120 | [Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
+121 | [Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
+122 | [Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java)
+123 | [Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java)
+124 | [Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java)
+125 | [Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java)
+126 | [Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
+127 | [Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
+128 | [Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
+129 | [Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
+130 | [Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
+131 | [Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
+132 | [Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java)
+133 | [Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
+134 | [Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
+135 | [Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java)
+136 | [Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java)
+137 | [Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java)
+138 | [Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
+139 | [Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
+140 | [Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java)
+141 | [Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
+142 | [Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
+143 | [Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
+144 | [Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
+145 | [Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
+146 | [Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
+147 | [Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
+148 | [Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
+149 | [Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
+150 | [Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
+151 | [Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
+152 | [Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java)
+153 | [Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
+154 | [Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java)
+155 | [Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
+156 | [Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
+157 | [Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
+158 | [Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
+159 | [Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
+160 | [Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java)
+161 | [Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
+162 | [Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
+163 | [Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
+164 | [Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java)
+165 | [Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java)
+166 | [Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
+167 | [Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
+168 | [Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
+169 | [Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
+170 | [Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
+171 | [Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java)
+172 | [Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java)
+173 | [Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
+174 | [Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
+175 | [Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
+176 | [Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
+177 | [Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
+178 | [Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
+179 | [Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java)
+180 | [Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
+181 | [Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
+182 | [Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
+183 | [Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
+184 | [Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java)
+185 | [Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
+186 | [Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
+187 | [Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
+188 | [Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java)
+189 | [Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
+190 | [Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
+191 | [Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java)
+192 | [Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
+193 | [Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java)
+194 | [Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
+195 | [Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
+196 | [Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java)
+197 | [Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java)
+198 | [Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
+199 | [Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
+200 | [Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java)
+201 | [Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java)
+202 | [Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java)
+203 | [Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
+204 | [Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
+205 | [Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
+206 | [Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
+207 | [Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
+208 | [Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
+209 | [Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
+210 | [Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
+211 | [Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
+212 | [Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
+213 | [Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java)
+214 | [Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
+215 | [Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java)
+216 | [Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
+217 | [Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
+218 | [Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java)
+219 | [Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
+220 | [Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
+221 | [Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
+222 | [Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java)
+223 | [Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java)
+224 | [Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
+225 | [Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
+226 | [Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
+227 | [Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
+228 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
+229 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
+230 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java)
+231 | [Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java)
+232 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
+233 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
+234 | [Find the Maximum Divisibility Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Maximum%20Divisibility%20Score.java)
+235 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java)
+236 | [Find the Score of All Prefixes of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array.java)
+237 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
+238 | [Find the Substring With Maximum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Substring%20With%20Maximum%20Cost.java)
+239 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
+240 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
+241 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
+242 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
+243 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
+244 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
+245 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
+246 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
+247 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
+248 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
+249 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
+250 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java)
+251 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
+252 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java)
+253 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
+254 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
+255 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
+256 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
+257 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
+258 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
+259 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
+260 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
+261 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
+262 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
+263 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
+264 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
+265 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
+266 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
+267 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
+268 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
+269 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java)
+270 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java)
+271 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
+272 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
+273 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
+274 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java)
+275 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
+276 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
+277 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
+278 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
+279 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
+280 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
+281 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java)
+282 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
+283 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
+284 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
+285 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
+286 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
+287 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
+288 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java)
+289 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
+290 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
+291 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
+292 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
+293 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java)
+294 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java)
+295 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java)
+296 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
+297 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java)
+298 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java)
+299 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
+300 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
+301 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
+302 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
+303 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
+304 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
+305 | [Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java)
+306 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
+307 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
+308 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java)
+309 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
+310 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
+311 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
+312 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java)
+313 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
+314 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
+315 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
+316 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
+317 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java)
+318 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
+319 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
+320 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java)
+321 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java)
+322 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
+323 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
+324 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
+325 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
+326 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
+327 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
+328 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
+329 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
+330 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java)
+331 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
+332 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
+333 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java)
+334 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
+335 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
+336 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
+337 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
+338 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java)
+339 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
+340 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
+341 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+342 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java)
+343 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
+344 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java)
+345 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
+346 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
+347 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
+348 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java)
+349 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
+350 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
+351 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
+352 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
+353 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
+354 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java)
+355 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java)
+356 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
+357 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
+358 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
+359 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
+360 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java)
+361 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
+362 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java)
+363 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
+364 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java)
+365 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java)
+366 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
+367 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java)
+368 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
+369 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java)
+370 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
+371 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
+372 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java)
+373 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
+374 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
+375 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
+376 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
+377 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
+378 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java)
+379 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
+380 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
+381 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java)
+382 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java)
+383 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java)
+384 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java)
+385 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java)
+386 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java)
+387 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
+388 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
+389 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
+390 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java)
+391 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
+392 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java)
+393 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java)
+394 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
+395 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java)
+396 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
+397 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java)
+398 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java)
+399 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java)
+400 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java)
+401 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java)
+402 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java)
+403 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java)
+404 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
+405 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
+406 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
+407 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
+408 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
+409 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
+410 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
+411 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
+412 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
+413 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java)
+414 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java)
+415 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java)
+416 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
+417 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
+418 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
+419 | [Minimize Maximum of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20of%20Array.java)
+420 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java)
+421 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
+422 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java)
+423 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
+424 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java)
+425 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java)
+426 | [Minimum Cost For Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20For%20Tickets.java)
+427 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
+428 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
+429 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java)
+430 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
+431 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
+432 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java)
+433 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java)
+434 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
+435 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java)
+436 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
+437 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
+438 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
+439 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java)
+440 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java)
+441 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
+442 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java)
+443 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
+444 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
+445 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
+446 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
+447 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
+448 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
+449 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java)
+450 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
+451 | [Minimum Score of a Path Between Two Cities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20of%20a%20Path%20Between%20Two%20Cities.java)
+452 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
+453 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java)
+454 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
+455 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java)
+456 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java)
+457 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java)
+458 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java)
+459 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
+460 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
+461 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java)
+462 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java)
+463 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
+464 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
+465 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
+466 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
+467 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java)
+468 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java)
+469 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
+470 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
+471 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
+472 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
+473 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
+474 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
+475 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java)
+476 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
+477 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java)
+478 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
+479 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java)
+480 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
+481 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java)
+482 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
+483 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
+484 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
+485 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java)
+486 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java)
+487 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
+488 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java)
+489 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
+490 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
+491 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
+492 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
+493 | [Number of Operations to Make Network Connected](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Operations%20to%20Make%20Network%20Connected.java)
+494 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java)
+495 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java)
+496 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java)
+497 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java)
+498 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
+499 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
+500 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
+501 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
+502 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java)
+503 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java)
+504 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
+505 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
+506 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
+507 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java)
+508 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
+509 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
+510 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
+511 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
+512 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java)
+513 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java)
+514 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
+515 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java)
+516 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
+517 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
+518 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
+519 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java)
+520 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java)
+521 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java)
+522 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
+523 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
+524 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
+525 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
+526 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java)
+527 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
+528 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
+529 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
+530 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
+531 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
+532 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
+533 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
+534 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
+535 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
+536 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
+537 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
+538 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
+539 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
+540 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java)
+541 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
+542 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java)
+543 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
+544 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
+545 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
+546 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
+547 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
+548 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
+549 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
+550 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java)
+551 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
+552 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
+553 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java)
+554 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java)
+555 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
+556 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
+557 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
+558 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
+559 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
+560 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
+561 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
+562 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
+563 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
+564 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
+565 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
+566 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java)
+567 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java)
+568 | [Rearrange Array to Maximize Prefix Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20to%20Maximize%20Prefix%20Score.java)
+569 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
+570 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java)
+571 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
+572 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
+573 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
+574 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
+575 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
+576 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java)
+577 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
+578 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
+579 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
+580 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
+581 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java)
+582 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
+583 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
+584 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
+585 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java)
+586 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
+587 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
+588 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
+589 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java)
+590 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java)
+591 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
+592 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
+593 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java)
+594 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
+595 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
+596 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java)
+597 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
+598 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
+599 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
+600 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java)
+601 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
+602 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java)
+603 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java)
+604 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
+605 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
+606 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
+607 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
+608 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
+609 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
+610 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
+611 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
+612 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java)
+613 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
+614 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java)
+615 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
+616 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
+617 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
+618 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
+619 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java)
+620 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
+621 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
+622 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
+623 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
+624 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
+625 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
+626 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
+627 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java)
+628 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
+629 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
+630 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
+631 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
+632 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
+633 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
+634 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java)
+635 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
+636 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
+637 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
+638 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java)
+639 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
+640 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
+641 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
+642 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
+643 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java)
+644 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
+645 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
+646 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
+647 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
+648 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
+649 | [Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java)
+650 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
+651 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
+652 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java)
+653 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
+654 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java)
+655 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
+656 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
+657 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
+658 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
+659 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
+660 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
+661 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java)
+662 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
+663 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
+664 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java)
+665 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
+666 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java)
+667 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
+668 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
+669 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
+670 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
+671 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
+672 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java)
+673 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
+674 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java)
+675 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java)
+676 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java)
+677 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java)
+678 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java)
+679 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
+680 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
+681 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
+682 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java)
+683 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
+684 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
+685 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
+686 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java)
+687 | [Sum Multiples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Multiples.java)
+688 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
+689 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
+690 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java)
+691 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java)
+692 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
+693 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java)
+694 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java)
+695 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
+696 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
+697 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
+698 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
+699 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
+700 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java)
+701 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
+702 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
+703 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
+704 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
+705 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
+706 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java)
+707 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
+708 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
+709 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
+710 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
+711 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
+712 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java)
+713 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
+714 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
+715 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
+716 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java)
+717 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java)
+718 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
+719 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
+720 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java)
+721 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java)
+722 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
+723 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java)
+724 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java)
+725 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
+726 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
+727 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
+728 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
+729 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
+730 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
+731 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
+732 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
+733 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
+734 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
+735 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
+736 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
+737 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
+738 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
+739 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
+740 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
+741 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java)
+742 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
+743 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
+744 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java)
+745 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
+746 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
+747 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java)
+748 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
+749 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
+750 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
+751 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java)
+752 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
+753 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
diff --git a/README.md b/README.md
index e264f9eb..dd9ecf17 100644
--- a/README.md
+++ b/README.md
@@ -2,12 +2,12 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 1200+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1300+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count
 --- | --- 
-[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 558
-[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 739
-[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 95
+[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 572
+[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 754
+[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 111
 [Concurrency](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Concurrency/README.md) | 9

From 55c8a9b396780f5817aec3b36db8648a1df6e1e8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 29 Apr 2023 19:02:30 -0700
Subject: [PATCH 1646/2175] Added Find the Prefix Common Array of Two
 Arrays.java

---
 ...d the Prefix Common Array of Two Arrays.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Find the Prefix Common Array of Two Arrays.java

diff --git a/Medium/Find the Prefix Common Array of Two Arrays.java b/Medium/Find the Prefix Common Array of Two Arrays.java
new file mode 100644
index 00000000..bd747227
--- /dev/null
+++ b/Medium/Find the Prefix Common Array of Two Arrays.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] findThePrefixCommonArray(int[] A, int[] B) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int count = 0;
+        int[] result = new int[A.length];
+        for (int i = 0; i < A.length; i++) {
+            map.put(A[i], map.getOrDefault(A[i], 0) + 1);
+            map.put(B[i], map.getOrDefault(B[i], 0) + 1);
+            count += map.get(A[i]) == 2 ? 1 : 0;
+            if (A[i] != B[i]) {
+                count += map.get(B[i]) == 2 ? 1 : 0;
+            }
+            result[i] = count;
+        }
+        return result;
+    }
+}

From 391f217baa1c169f95dde4176cd3ca3e52bcbacc Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 30 Apr 2023 10:32:51 -0700
Subject: [PATCH 1647/2175] Added Determine the Winner of a Bowling Game.java

---
 ...etermine the Winner of a Bowling Game.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Determine the Winner of a Bowling Game.java

diff --git a/Easy/Determine the Winner of a Bowling Game.java b/Easy/Determine the Winner of a Bowling Game.java
new file mode 100644
index 00000000..0b64db30
--- /dev/null
+++ b/Easy/Determine the Winner of a Bowling Game.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int isWinner(int[] player1, int[] player2) {
+        int score1 = 0;
+        int score2 = 0;
+        int tenIndex1 = -1;
+        int tenIndex2 = -1;
+        for (int i = 0; i < player1.length; i++) {
+            score1 += player1[i];
+            score2 += player2[i];
+            if (tenIndex1 != -1 && i - tenIndex1 <= 2) {
+                score1 += player1[i];
+            }
+            if (tenIndex2 != -1 && i - tenIndex2 <= 2) {
+                score2 += player2[i];
+            }
+            if (player1[i] == 10) {
+                tenIndex1 = i;
+            }
+            if (player2[i] == 10) {
+                tenIndex2 = i;
+            }
+        }
+        return score1 > score2 ? 1 : (score1 == score2 ? 0 : 2);
+    }
+}

From f348fed45d237066c75b1aae9784c346ce853cb2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Apr 2023 13:56:37 -0700
Subject: [PATCH 1648/2175] Create Remove Max Number of Edges to Keep Graph
 Fully Traversable.java

---
 ...Edges to Keep Graph Fully Traversable.java | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java

diff --git a/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java b/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java
new file mode 100644
index 00000000..152ab81b
--- /dev/null
+++ b/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java	
@@ -0,0 +1,67 @@
+class Solution {
+    public int maxNumEdgesToRemove(int n, int[][] edges) {
+        UnionFind alice = new UnionFind(n);
+        UnionFind bob = new UnionFind(n);
+        int requiredEdges = 0;
+        for (int[] edge : edges) {
+            if (edge[0] == 3) {
+                requiredEdges += (alice.union(edge[1], edge[2]) | bob.union(edge[1], edge[2]));
+            }
+        }
+        for (int[] edge : edges) {
+            if (edge[0] == 1) {
+                requiredEdges += alice.union(edge[1], edge[2]);
+            } else if (edge[0] == 2) {
+                requiredEdges += bob.union(edge[1], edge[2]);
+            }
+        }
+        if (alice.isConnected() && bob.isConnected()) {
+            return edges.length - requiredEdges;
+        }
+        return -1;
+    }
+    
+    private class UnionFind {
+        private final int[] representatives;
+        private final int[] componentSize;
+        private int components;
+        
+        public UnionFind(int n) {
+            this.representatives = new int[n + 1];
+            this.componentSize = new int[n + 1];
+            this.components = n;
+            for (int i = 0; i <= n; i++) {
+                componentSize[i] = 1;
+                representatives[i] = i;
+            }
+        }
+        
+        public int find(int x) {
+            if (representatives[x] == x) {
+                return x;
+            }
+            return representatives[x] = find(representatives[x]);
+        }
+        
+        public int union(int x, int y) {
+            x = find(x);
+            y = find(y);
+            if (x == y) {
+                return 0;
+            }
+            if (componentSize[x] > componentSize[y]) {
+                componentSize[x] += componentSize[y];
+                representatives[y] = x;
+            } else {
+                componentSize[y] += componentSize[x];
+                representatives[x] = y;
+            }
+            components--;
+            return 1;
+        }
+        
+        public boolean isConnected() {
+            return components == 1;
+        }
+    }
+}

From fef17fd274e589de7b4986fe89d487fbe3f96393 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 30 Apr 2023 18:38:33 -0700
Subject: [PATCH 1649/2175] Updated Average Salary Excluding the Minimum and
 Maximum Salary.java

---
 ...luding the Minimum and Maximum Salary.java | 22 +++++++++----------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/Easy/Average Salary Excluding the Minimum and Maximum Salary.java b/Easy/Average Salary Excluding the Minimum and Maximum Salary.java
index 08d8663e..1d4d872c 100644
--- a/Easy/Average Salary Excluding the Minimum and Maximum Salary.java	
+++ b/Easy/Average Salary Excluding the Minimum and Maximum Salary.java	
@@ -1,15 +1,13 @@
 class Solution {
-  public double average(int[] salary) {
-    int minSalary = salary[0];
-    int maxSalary = salary[0];
-    int n = salary.length;
-    int sum = 0;
-    for (int i = 0; i < n; i++) {
-      sum += salary[i];
-      minSalary = Math.min(minSalary, salary[i]);
-      maxSalary = Math.max(maxSalary, salary[i]);
+    public double average(int[] salary) {
+        int minSalary = salary[0];
+        int maxSalary = salary[0];
+        double totalSalary = 0;
+        for (int s : salary) {
+            minSalary = Math.min(minSalary, s);
+            maxSalary = Math.max(maxSalary, s);
+            totalSalary += s;
+        }
+        return (totalSalary - minSalary - maxSalary) / (salary.length - 2);
     }
-    sum -= (maxSalary + minSalary);
-    return ((double) sum) / (n - 2);
-  }
 }

From 1b421f46b4e527373527938d5a12473f6fd8eb2f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 30 Apr 2023 18:47:16 -0700
Subject: [PATCH 1650/2175] Updated Index Pairs of a String.java

---
 Easy/Index Pairs of a String.java | 56 ++++++-------------------------
 1 file changed, 10 insertions(+), 46 deletions(-)

diff --git a/Easy/Index Pairs of a String.java b/Easy/Index Pairs of a String.java
index 97d590ce..5fd32b1e 100644
--- a/Easy/Index Pairs of a String.java	
+++ b/Easy/Index Pairs of a String.java	
@@ -1,50 +1,14 @@
 class Solution {
-  public int[][] indexPairs(String text, String[] words) {
-    TrieNode root = new TrieNode('-');
-    for (String word : words) {
-      addWord(word, root);
-    }
-    List<int[]> list = new ArrayList<>();
-    for (int i = 0; i < text.length(); i++) {
-      int j = i;
-      TrieNode curr = root;
-      while (j < text.length() && curr.childrens.containsKey(text.charAt(j))) {
-        curr = curr.childrens.get(text.charAt(j));
-        if (curr.isWord) {
-          list.add(new int[]{i, j});
+    public int[][] indexPairs(String text, String[] words) {
+        List<int[]> pairs = new ArrayList<>();
+        for (String word : words) {
+            for (int i = 0; i < text.length() - word.length() + 1; i++) {
+                if (text.startsWith(word, i)) {
+                    pairs.add(new int[]{i, i + word.length() - 1});
+                }
+            }
         }
-        j++;
-      }
-    }
-    int[][] ans = new int[list.size()][2];
-    for (int i = 0; i < list.size(); i++) {
-      ans[i] = list.get(i);
+        pairs.sort(Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1]));
+        return pairs.toArray(new int[0][]);
     }
-    return ans;
-  }
-  
-  private void addWord(String s, TrieNode root) {
-    for (int i = 0; i < s.length(); i++) {
-      if (!root.childrens.containsKey(s.charAt(i))) {
-        root.childrens.put(s.charAt(i), new TrieNode(s.charAt(i)));
-      }
-      root = root.childrens.get(s.charAt(i));
-      if (i == s.length() - 1) {
-        root.isWord = true;
-      }
-    }
-  }
-}
-
-
-class TrieNode {
-  char c;
-  Map<Character, TrieNode> childrens;
-  boolean isWord;
-  
-  public TrieNode(char c) {
-    this.c = c;
-    childrens = new HashMap<>();
-    isWord = false;
-  }
 }

From 0edbde0debe23895091975afc288ab1b264e0eb4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 1 May 2023 17:36:26 -0700
Subject: [PATCH 1651/2175] Updated Sign of the Product of an Array.java

---
 Easy/Sign of the Product of an Array.java | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Easy/Sign of the Product of an Array.java b/Easy/Sign of the Product of an Array.java
index 8f286c24..b4f1172c 100644
--- a/Easy/Sign of the Product of an Array.java	
+++ b/Easy/Sign of the Product of an Array.java	
@@ -1,12 +1,12 @@
 class Solution {
-  public int arraySign(int[] nums) {
-    int negativeCount = 0;
-    for (int num : nums) {
-      if (num == 0) {
-        return 0;
-      }
-      negativeCount += num < 0 ? 1 : 0;
+    public int arraySign(int[] nums) {
+        int negCount = 0;
+        for (int num : nums) {
+            if (num == 0) {
+                return 0;
+            }
+            negCount += num > 0 ? 0 : 1;
+        }
+        return negCount % 2 == 0 ? 1 : -1;
     }
-    return negativeCount % 2 == 0 ? 1 : -1;
-  }
 }

From 757ae7369d60f144e74af0eed50057e078ea16fa Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 3 May 2023 06:48:54 -0700
Subject: [PATCH 1652/2175] Updated Building H2O.java

---
 Concurrency/Building H2O.java | 40 +++++++++++++++++------------------
 1 file changed, 19 insertions(+), 21 deletions(-)

diff --git a/Concurrency/Building H2O.java b/Concurrency/Building H2O.java
index 2d2dee57..04fda0bc 100644
--- a/Concurrency/Building H2O.java	
+++ b/Concurrency/Building H2O.java	
@@ -1,26 +1,24 @@
 class H2O {
-  
-  private final Semaphore hydrogenSemaphore;
-  private final Semaphore oxygenSemaphore;
+    
+    private Semaphore hydrogenSemaphore;
+    private Semaphore oxygenSemaphore;
 
-  public H2O() {
-    this.hydrogenSemaphore = new Semaphore(2);
-    this.oxygenSemaphore = new Semaphore(0);
-  }
+    public H2O() {
+        this.hydrogenSemaphore = new Semaphore(2);
+        this.oxygenSemaphore = new Semaphore(0);
+    }
 
-  public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+		hydrogenSemaphore.acquire();
+        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
+        releaseHydrogen.run();
+        this.oxygenSemaphore.release();
+    }
 
-    this.hydrogenSemaphore.acquire();
-    // releaseHydrogen.run() outputs "H". Do not change or remove this line.
-    releaseHydrogen.run();
-    this.oxygenSemaphore.release();
-  }
-
-  public void oxygen(Runnable releaseOxygen) throws InterruptedException {
-
-    this.oxygenSemaphore.acquire(2);
-    // releaseOxygen.run() outputs "O". Do not change or remove this line.
-    releaseOxygen.run();
-    this.hydrogenSemaphore.release(2);
-  }
+    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
+        this.oxygenSemaphore.acquire(2);
+        // releaseOxygen.run() outputs "O". Do not change or remove this line.
+		releaseOxygen.run();
+        this.hydrogenSemaphore.release(2);
+    }
 }

From 29c9d6db7191ab8082bf2d082ff75211a9b7f44d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 May 2023 06:17:28 -0700
Subject: [PATCH 1653/2175] Create Dota2 Senate.java

---
 Medium/Dota2 Senate.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Dota2 Senate.java

diff --git a/Medium/Dota2 Senate.java b/Medium/Dota2 Senate.java
new file mode 100644
index 00000000..56465cb4
--- /dev/null
+++ b/Medium/Dota2 Senate.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public String predictPartyVictory(String senate) {
+        int n = senate.length();
+        Queue<Integer> rValid = new LinkedList<>();
+        Queue<Integer> dValid = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            if (senate.charAt(i) == 'R') {
+                rValid.add(i);
+            } else {
+                dValid.add(i);
+            }
+        }
+        while (!rValid.isEmpty() && !dValid.isEmpty()) {
+            int rTurn = rValid.remove();
+            int dTurn = dValid.remove();
+            if (dTurn < rTurn) {
+                dValid.add(dTurn + n);
+            } else {
+                rValid.add(rTurn + n);
+            }
+        }
+        return rValid.isEmpty() ? "Dire" : "Radiant";
+    }
+}

From 6eddbb3029c37553f7429a96a906fc8cc36394ed Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 May 2023 17:52:00 -0700
Subject: [PATCH 1654/2175] Update Maximum Number of Vowels in a Substring of
 Given Length.java

---
 ...Vowels in a Substring of Given Length.java | 49 ++++++++-----------
 1 file changed, 20 insertions(+), 29 deletions(-)

diff --git a/Medium/Maximum Number of Vowels in a Substring of Given Length.java b/Medium/Maximum Number of Vowels in a Substring of Given Length.java
index 5af78c54..0b27eda9 100644
--- a/Medium/Maximum Number of Vowels in a Substring of Given Length.java	
+++ b/Medium/Maximum Number of Vowels in a Substring of Given Length.java	
@@ -1,32 +1,23 @@
 class Solution {
-  public int maxVowels(String s, int k) {
-    Map<Character, Integer> map = new HashMap<>();
-    String vowels = "aeiou";
-    int count = 0;
-    int maxCount = 0;
-    int start = 0;
-    int end = 0;
-    int n = s.length();
-    while (end < (k - 1)) {
-      if (vowels.indexOf(s.charAt(end)) != -1) {
-        map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
-        count++;
-      }
-      end++;
+    public int maxVowels(String s, int k) {
+        int currCount = 0;
+        Set<Character> vowels = Set.of('a', 'e', 'i', 'o', 'u');
+        for (int i = 0; i < k - 1; i++) {
+            if (vowels.contains(s.charAt(i))) {
+                currCount++;
+            }
+        }
+        int maxCount = 0;
+        int start = 0;
+        for (int i = k - 1; i < s.length(); i++) {
+            if (vowels.contains(s.charAt(i))) {
+                currCount++;
+            }
+            maxCount = Math.max(maxCount, currCount);
+            if (vowels.contains(s.charAt(start++))) {
+                currCount--;
+            }
+        }
+        return maxCount;
     }
-    while (end < n) {
-       if (vowels.indexOf(s.charAt(end)) != -1) {
-        map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
-         count++;
-      }
-      end++;
-      maxCount = Math.max(maxCount, count);
-      if (vowels.indexOf(s.charAt(start)) != -1) {
-        map.put(s.charAt(start), map.getOrDefault(s.charAt(start), 0) - 1);
-        count--;
-      }
-      start++;
-    }
-    return maxCount;
-  }
 }

From f22f7a0473ee59a43875dc1987e03d0dcf03367c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 6 May 2023 07:27:19 -0700
Subject: [PATCH 1655/2175] Added Number of Subsequences That Satisfy the Given
 Sum Condition.java

---
 ... That Satisfy the Given Sum Condition.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Number of Subsequences That Satisfy the Given Sum Condition.java

diff --git a/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java b/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java
new file mode 100644
index 00000000..9a40ee6b
--- /dev/null
+++ b/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java	
@@ -0,0 +1,26 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int numSubseq(int[] nums, int target) {
+        int n = nums.length;
+        Arrays.sort(nums);
+        int[] power = new int[n];
+        power[0] = 1;
+        for (int i = 1; i < n; i++) {
+            power[i] = (power[i - 1] * 2) % MOD;
+        }
+        int result = 0;
+        int left = 0;
+        int right = n - 1;
+        while (left <= right) {
+            if (nums[left] + nums[right] <= target) {
+                result = (result + power[right - left]) % MOD;
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return result;
+    }
+}

From 50dee52b80df69c6bea25983c4830e5a8e5082b8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 7 May 2023 07:29:52 -0700
Subject: [PATCH 1656/2175] Added Find the Distinct Difference Array.java

---
 Easy/Find the Distinct Difference Array.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Find the Distinct Difference Array.java

diff --git a/Easy/Find the Distinct Difference Array.java b/Easy/Find the Distinct Difference Array.java
new file mode 100644
index 00000000..5578427f
--- /dev/null
+++ b/Easy/Find the Distinct Difference Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] distinctDifferenceArray(int[] nums) {
+        int[] rightToLeft = new int[nums.length];
+        Set<Integer> set = new HashSet<>();
+        for (int i = nums.length - 1; i >= 0; i--) {
+            set.add(nums[i]);
+            rightToLeft[i] = set.size();
+        }
+        int[] diff = new int[nums.length];
+        set.clear();
+        for (int i = 0; i < nums.length; i++) {
+            set.add(nums[i]);
+            diff[i] = set.size() - (i == nums.length - 1 ? 0 : rightToLeft[i + 1]);
+        }
+        return diff;
+    }
+}

From b1722b789cc13e48f6565ab9229e3e4de6df97f8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 7 May 2023 10:07:32 -0700
Subject: [PATCH 1657/2175] Added Find the Longest Valid Obstacle Course at
 Each Position.java

---
 ...alid Obstacle Course at Each Position.java | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Hard/Find the Longest Valid Obstacle Course at Each Position.java

diff --git a/Hard/Find the Longest Valid Obstacle Course at Each Position.java b/Hard/Find the Longest Valid Obstacle Course at Each Position.java
new file mode 100644
index 00000000..fcd272fb
--- /dev/null
+++ b/Hard/Find the Longest Valid Obstacle Course at Each Position.java	
@@ -0,0 +1,34 @@
+class Solution {
+    public int[] longestObstacleCourseAtEachPosition(int[] obstacles) {
+        int n = obstacles.length;
+        int lisLength = 0;
+        int[] result = new int[n];
+        int[] lis = new int[n];
+        for (int i = 0; i < n; i++) {
+            int height = obstacles[i];
+            int idx = bisect(lis, height, lisLength);
+            if (idx == lisLength) {
+                lisLength++;
+            }
+            lis[idx] = height;
+            result[i] = idx + 1;
+        }
+        return result;
+    }
+    
+    private int bisect(int[] lis, int target, int right) {
+        if (right == 0) {
+            return 0;
+        }
+        int left = 0;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (lis[mid] <= target) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+}

From bd776c303881b9f273ef41abf502586a59f5dc64 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 7 May 2023 10:19:42 -0700
Subject: [PATCH 1658/2175] Added Frequency Tracker.java

---
 Medium/Frequency Tracker.java | 48 +++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 Medium/Frequency Tracker.java

diff --git a/Medium/Frequency Tracker.java b/Medium/Frequency Tracker.java
new file mode 100644
index 00000000..e5e83453
--- /dev/null
+++ b/Medium/Frequency Tracker.java	
@@ -0,0 +1,48 @@
+class FrequencyTracker {
+
+    private final Map<Integer, Integer> numToFrequencyMapping;
+    private final Map<Integer, Set<Integer>> frequencyToNumMapping;
+
+    public FrequencyTracker() {
+        this.numToFrequencyMapping = new HashMap<>();
+        this.frequencyToNumMapping = new HashMap<>();
+    }
+
+    public void add(int number) {
+        int prevFrequency = this.numToFrequencyMapping.getOrDefault(number, 0);
+        int newFrequency = prevFrequency + 1;
+        this.numToFrequencyMapping.put(number, newFrequency);
+        updateFreqToNumMapping(number, prevFrequency, newFrequency);
+    }
+
+    public void deleteOne(int number) {
+        int prevFrequency = this.numToFrequencyMapping.getOrDefault(number, 0);
+        if (prevFrequency == 0) {
+            return;
+        }
+        int newFrequency = prevFrequency - 1;
+        this.numToFrequencyMapping.put(number, newFrequency);
+        updateFreqToNumMapping(number, prevFrequency, newFrequency);
+    }
+
+    public boolean hasFrequency(int frequency) {
+        return this.frequencyToNumMapping.getOrDefault(frequency, new HashSet<>()).size() > 0;
+    }
+
+    private void updateFreqToNumMapping(int number, int prevFrequency, int newFrequency) {
+        if (prevFrequency != 0) {
+            this.frequencyToNumMapping.get(prevFrequency).remove(number);
+        }
+        if (newFrequency != 0) {
+            this.frequencyToNumMapping.computeIfAbsent(newFrequency, k -> new HashSet<>()).add(number);
+        }
+    }
+}
+
+/**
+ * Your FrequencyTracker object will be instantiated and called as such:
+ * FrequencyTracker obj = new FrequencyTracker();
+ * obj.add(number);
+ * obj.deleteOne(number);
+ * boolean param_3 = obj.hasFrequency(frequency);
+ */

From 0b2f422764938ae75bbcc4cc4550e1940f99dce8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 May 2023 12:46:46 -0700
Subject: [PATCH 1659/2175] Update Find Minimum in Rotated Sorted Array.java

---
 .../Find Minimum in Rotated Sorted Array.java | 41 +++++++------------
 1 file changed, 14 insertions(+), 27 deletions(-)

diff --git a/Medium/Find Minimum in Rotated Sorted Array.java b/Medium/Find Minimum in Rotated Sorted Array.java
index 8c18f17b..79ae6e51 100644
--- a/Medium/Find Minimum in Rotated Sorted Array.java	
+++ b/Medium/Find Minimum in Rotated Sorted Array.java	
@@ -1,30 +1,17 @@
 class Solution {
-  public int findMin(int[] nums) {
-    if (nums.length == 1) {
-      return nums[0];
+    public int findMin(int[] nums) {
+        int start = 0;
+        int end = nums.length - 1;
+        int minValue = 5001;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            minValue = Math.min(minValue, nums[mid]);
+            if (nums[end] > nums[mid]) {
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return minValue;
     }
-    int left = 0;
-    int right = nums.length - 1;
-    // Sorted but not rotated
-    if (nums[right] > nums[left]) {
-      return nums[left];
-    }
-    while (left <= right) {
-      int mid = (left + right) / 2;
-      // mid + 1 is point of rotation
-      if (nums[mid] > nums[mid + 1]) {
-        return nums[mid + 1];
-      }
-      // mid is point of rotation
-      if (nums[mid - 1] > nums[mid]) {
-        return nums[mid];
-      }
-      if (nums[mid] > nums[0]) {
-        left = mid + 1;
-      } else {
-        right = mid - 1;
-      }
-    }
-    return Integer.MAX_VALUE;
-  }
 }

From 1bfdf2dbabea029b8826106b024e3b872002d2a6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 May 2023 17:33:46 -0700
Subject: [PATCH 1660/2175] Update Spiral Matrix.java

---
 Medium/Spiral Matrix.java | 56 +++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/Medium/Spiral Matrix.java b/Medium/Spiral Matrix.java
index 6004fe4d..252374fb 100644
--- a/Medium/Spiral Matrix.java	
+++ b/Medium/Spiral Matrix.java	
@@ -1,32 +1,32 @@
 class Solution {
-  public List<Integer> spiralOrder(int[][] matrix) {
-    List<Integer> list = new ArrayList<>();
-    int rowStart = 0;
-    int rowEnd = matrix.length - 1;
-    int colStart = 0;
-    int colEnd = matrix[0].length - 1;
-    while (rowStart <= rowEnd && colStart <= colEnd) {
-      for (int i = colStart; i <= colEnd; i++) {
-        list.add(matrix[rowStart][i]);
-      }
-      rowStart++;
-      for (int i = rowStart; i <= rowEnd; i++) {
-        list.add(matrix[i][colEnd]);
-      }
-      colEnd--;
-      if (rowStart <= rowEnd) {
-        for (int i = colEnd; i >= colStart; i--) {
-          list.add(matrix[rowEnd][i]);
+    public List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> result = new ArrayList<>();
+        int rowStart = 0;
+        int rowEnd = matrix.length - 1;
+        int colStart = 0;
+        int colEnd = matrix[0].length - 1;
+        while (rowStart <= rowEnd && colStart <= colEnd) {
+            for (int i = colStart; i <= colEnd; i++) {
+                result.add(matrix[rowStart][i]);
+            }
+            rowStart++;
+            for (int i = rowStart; i <= rowEnd; i++) {
+                result.add(matrix[i][colEnd]);
+            }
+            colEnd--;
+            if (rowStart <= rowEnd) {
+                for (int i = colEnd; i >= colStart; i--) {
+                    result.add(matrix[rowEnd][i]);
+                }
+                rowEnd--;
+            }
+            if (colStart <= colEnd) {
+                for (int i = rowEnd; i >= rowStart; i--) {
+                    result.add(matrix[i][colStart]);
+                }
+                colStart++;
+            }
         }
-        rowEnd--;
-      }
-      if (colStart <= colEnd) {
-        for (int i = rowEnd; i >= rowStart; i--) {
-          list.add(matrix[i][colStart]);
-        }
-        colStart++;
-      }
+        return result;
     }
-    return list;
-  }
 }

From 74fc658d62e964a2272d7e76fc0aebec8fc92549 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 9 May 2023 07:20:28 -0700
Subject: [PATCH 1661/2175] Added Find the Pivot Integer.java

---
 Easy/Find the Pivot Integer.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Find the Pivot Integer.java

diff --git a/Easy/Find the Pivot Integer.java b/Easy/Find the Pivot Integer.java
new file mode 100644
index 00000000..3cad5e0b
--- /dev/null
+++ b/Easy/Find the Pivot Integer.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int pivotInteger(int n) {
+        int[] leftToRightSum = new int[n];
+        int currSum = 0;
+        for (int i = 0; i < n; i++) {
+            currSum += i + 1;
+            leftToRightSum[i] = currSum;
+        }
+        int rightToLeftSum = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            rightToLeftSum += i + 1;
+            if (leftToRightSum[i] == rightToLeftSum) {
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+}

From ba891a7557b17607eff32ffc242b162afc81a62b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 9 May 2023 07:22:40 -0700
Subject: [PATCH 1662/2175] Added Delete Greatest Value in Each Row.java

---
 Easy/Delete Greatest Value in Each Row.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Delete Greatest Value in Each Row.java

diff --git a/Easy/Delete Greatest Value in Each Row.java b/Easy/Delete Greatest Value in Each Row.java
new file mode 100644
index 00000000..ca6794aa
--- /dev/null
+++ b/Easy/Delete Greatest Value in Each Row.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int deleteGreatestValue(int[][] grid) {
+        for (int[] g : grid) {
+            Arrays.sort(g);
+        }
+        int result = 0;
+        for (int i = grid[0].length - 1; i >= 0; i--) {
+            int maxValue = Integer.MIN_VALUE;
+            for (int[] g : grid) {
+                maxValue = Math.max(maxValue, g[i]);
+            }
+            result += maxValue;
+        }
+        return result;
+    }
+}

From ad7a72e85ed501b25be5277c7bca459f96c2c083 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 May 2023 17:34:01 -0700
Subject: [PATCH 1663/2175] Update Spiral Matrix II.java

---
 Medium/Spiral Matrix II.java | 56 +++++++++++++++++++-----------------
 1 file changed, 30 insertions(+), 26 deletions(-)

diff --git a/Medium/Spiral Matrix II.java b/Medium/Spiral Matrix II.java
index ffa09b62..636fbb69 100644
--- a/Medium/Spiral Matrix II.java	
+++ b/Medium/Spiral Matrix II.java	
@@ -1,29 +1,33 @@
 class Solution {
-  public int[][] generateMatrix(int n) {
-    int[][] ans = new int[n][n];
-    int left = 0;
-    int top = 0;
-    int right = n -1;
-    int down = n - 1;
-    int count = 1;
-    while (left <= right) {
-      for (int j = left; j <= right; j ++) {
-        ans[top][j] = count++;
-      }
-      top++;
-      for (int i = top; i <= down; i ++) {
-        ans[i][right] = count ++;
-      }
-      right--;
-      for (int j = right; j >= left; j --) {
-        ans[down][j] = count ++;
-      }
-      down--;
-      for (int i = down; i >= top; i --) {
-        ans[i][left] = count ++;
-      }
-      left++;
+    public int[][] generateMatrix(int n) {
+        int[][] result = new int[n][n];
+        int rowStart = 0;
+        int rowEnd = n - 1;
+        int colStart = 0;
+        int colEnd = n - 1;
+        int value = 1;
+        while (rowStart <= rowEnd && colStart <= colEnd) {
+            for (int i = colStart; i <= colEnd; i++) {
+                result[rowStart][i] = value++;
+            }
+            rowStart++;
+            for (int i = rowStart; i <= rowEnd; i++) {
+                result[i][colEnd] = value++;
+            }
+            colEnd--;
+            if (rowStart <= rowEnd) {
+                for (int i = colEnd; i >= colStart; i--) {
+                    result[rowEnd][i] = value++;
+                }
+                rowEnd--;
+            }
+            if (colStart <= colEnd) {
+                for (int i = rowEnd; i >= rowStart; i--) {
+                    result[i][colStart] = value++;
+                }
+                colStart++;
+            }
+        }
+        return result;
     }
-    return ans;
-  }
 }

From b3241878560e55031415baa1d6b4b473fb7d8a9e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 10 May 2023 17:09:27 -0700
Subject: [PATCH 1664/2175] Updated Uncrossed Lines.java

---
 Medium/Uncrossed Lines.java | 36 +++++++++++++++++-------------------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/Medium/Uncrossed Lines.java b/Medium/Uncrossed Lines.java
index 6a923dfa..729da13d 100644
--- a/Medium/Uncrossed Lines.java	
+++ b/Medium/Uncrossed Lines.java	
@@ -1,23 +1,21 @@
 class Solution {
-  Integer[][] dp;
-  public int maxUncrossedLines(int[] A, int[] B) {
-    dp = new Integer[A.length][B.length];
-    return helper(A, 0, B, 0);
-  } 
-  
-  private int helper(int[] A, int idxA, int[] B, int idxB) {
-    if (idxA == A.length || idxB == B.length) {
-      return 0;
-    } 
-    if (dp[idxA][idxB] != null) {
-      return dp[idxA][idxB];
+    public int maxUncrossedLines(int[] nums1, int[] nums2) {
+        Integer[][] dp = new Integer[nums1.length][nums2.length];
+        return helper(nums1, 0, nums2, 0, dp);
     }
-    if (A[idxA] == B[idxB]) {
-      dp[idxA][idxB] = 1 + helper(A, idxA + 1, B, idxB + 1);
+    
+    private int helper(int[] nums1, int idxOne, int[] nums2, int idxTwo, Integer[][] dp) {
+        if (idxOne == nums1.length || idxTwo == nums2.length) {
+            return 0;
+        }
+        if (dp[idxOne][idxTwo] != null) {
+            return dp[idxOne][idxTwo];
+        }
+        if (nums1[idxOne] == nums2[idxTwo]) {
+            return dp[idxOne][idxTwo] = 1 + helper(nums1, idxOne + 1, nums2, idxTwo + 1, dp);
+        }
+        return dp[idxOne][idxTwo] = Math.max(
+            helper(nums1, idxOne, nums2, idxTwo + 1, dp), 
+            helper(nums1, idxOne + 1, nums2, idxTwo, dp));
     }
-    else {
-      dp[idxA][idxB] = Math.max(helper(A, idxA + 1, B, idxB), helper(A, idxA, B, idxB + 1));
-    }
-    return dp[idxA][idxB];
-  }
 }

From a7228134a9273e85572939de02ac80e2fdc2b56e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 12 May 2023 06:33:01 -0700
Subject: [PATCH 1665/2175] Added Solving Questions With Brainpower.java

---
 Medium/Solving Questions With Brainpower.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Solving Questions With Brainpower.java

diff --git a/Medium/Solving Questions With Brainpower.java b/Medium/Solving Questions With Brainpower.java
new file mode 100644
index 00000000..76e640d1
--- /dev/null
+++ b/Medium/Solving Questions With Brainpower.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public long mostPoints(int[][] questions) {
+        Long[] dp = new Long[questions.length];
+        return helper(questions, 0, dp);
+    }
+    
+    private long helper(int[][] questions, int idx, Long[] dp) {
+        if (idx >= questions.length) {
+            return 0;
+        }
+        if (dp[idx] != null) {
+            return dp[idx];
+        }
+        return dp[idx] = Math.max(
+            questions[idx][0] + helper(questions, idx + questions[idx][1] + 1, dp),
+            helper(questions, idx + 1, dp)
+        );
+    }
+}

From 8d15a6b1d68e6d7df9ca39ea79f7b95a8264447a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 13 May 2023 14:28:40 -0700
Subject: [PATCH 1666/2175] Create Count Ways To Build Good Strings.java

---
 Medium/Count Ways To Build Good Strings.java | 23 ++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Count Ways To Build Good Strings.java

diff --git a/Medium/Count Ways To Build Good Strings.java b/Medium/Count Ways To Build Good Strings.java
new file mode 100644
index 00000000..16991f0c
--- /dev/null
+++ b/Medium/Count Ways To Build Good Strings.java	
@@ -0,0 +1,23 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int countGoodStrings(int low, int high, int zero, int one) {
+        int[] dp = new int[high + 1];
+        dp[0] = 1;
+        for (int i = 1; i <= high; i++) {
+            if (i >= zero) {
+                dp[i] += dp[i - zero];
+            } 
+            if (i >= one) {
+                dp[i] += dp[i - one];
+            }
+            dp[i] %= MOD;
+        }
+        int result = 0;
+        for (int i = low; i <= high; i++) {
+            result = (result + dp[i]) % MOD;
+        }
+        return result;
+    }
+}

From e1b690f7c5b690385c2d1c558e929a27c3545ab6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 13 May 2023 16:10:56 -0700
Subject: [PATCH 1667/2175] Added Number of Senior Citizens.java

---
 Easy/Number of Senior Citizens.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Number of Senior Citizens.java

diff --git a/Easy/Number of Senior Citizens.java b/Easy/Number of Senior Citizens.java
new file mode 100644
index 00000000..cb658ee0
--- /dev/null
+++ b/Easy/Number of Senior Citizens.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int countSeniors(String[] details) {
+        return (int) Arrays.stream(details)
+            .map(s -> Integer.parseInt(s.substring(11, 13)))
+            .filter(age -> age > 60)
+            .count();
+    }
+}

From f9e9563598991ee9e7cb14272da3b20d67c7a9ca Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 14 May 2023 06:14:49 -0700
Subject: [PATCH 1668/2175] Added Maximize Score After N Operations.java

---
 Hard/Maximize Score After N Operations.java | 37 +++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Hard/Maximize Score After N Operations.java

diff --git a/Hard/Maximize Score After N Operations.java b/Hard/Maximize Score After N Operations.java
new file mode 100644
index 00000000..2ed4f892
--- /dev/null
+++ b/Hard/Maximize Score After N Operations.java	
@@ -0,0 +1,37 @@
+class Solution {
+    public int maxScore(int[] nums) {
+        int dpSize = 1 << nums.length;
+        int[] dp = new int[dpSize];
+        Arrays.fill(dp, -1);
+        return backtrack(nums, 0, 0, dp);
+    }
+    
+    private int backtrack(int[] nums, int mask, int pickCount, int[] dp) {
+        if (2 * pickCount == nums.length) {
+            return 0;
+        }
+        if (dp[mask] != -1) {
+            return dp[mask];
+        }
+        int maxScore = 0;
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                if (((mask >> i) & 1) == 1 || ((mask >> j) & 1) == 1) {
+                    continue;
+                }
+                int newMask = mask | (1 << i) | (1 << j);
+                int curr = (pickCount + 1) * gcd(nums[i], nums[j]);
+                int remaining = backtrack(nums, newMask, pickCount + 1, dp);
+                maxScore = Math.max(maxScore, curr + remaining);
+            }
+        }
+        return dp[mask] = maxScore;
+    }
+    
+    private int gcd(int a, int b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+}

From 1e29e3ee9674379488ffc42f76324ec41fbf1e56 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 14 May 2023 06:25:15 -0700
Subject: [PATCH 1669/2175] Added Find the Losers of the Circular Game.java

---
 .../Find the Losers of the Circular Game.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Find the Losers of the Circular Game.java

diff --git a/Easy/Find the Losers of the Circular Game.java b/Easy/Find the Losers of the Circular Game.java
new file mode 100644
index 00000000..aaa8c059
--- /dev/null
+++ b/Easy/Find the Losers of the Circular Game.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int[] circularGameLosers(int n, int k) {
+        Set<Integer> set = new HashSet<>();
+        int player = 1;
+        int multiple = k;
+        while (set.add(player)) {
+            player = (player + k) % n;
+            player = player == 0 ? n : player;
+            k += multiple;
+        }
+        int[] result = new int[n - set.size()];
+        for (int i = 1, j = 0; i <= n; i++) {
+            if (!set.contains(i)) {
+                result[j++] = i;
+            }
+        }
+        return result;
+    }
+}

From 98e0c50250e0a49088c704bb0e13bb2ae4c843e7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 14 May 2023 15:55:33 -0700
Subject: [PATCH 1670/2175] Added Sum in a Matrix.java

---
 Medium/Sum in a Matrix.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Sum in a Matrix.java

diff --git a/Medium/Sum in a Matrix.java b/Medium/Sum in a Matrix.java
new file mode 100644
index 00000000..0261f81b
--- /dev/null
+++ b/Medium/Sum in a Matrix.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int matrixSum(int[][] nums) {
+        for (int[] num : nums) {
+            Arrays.sort(num);
+        }
+        int score = 0;
+        for (int i = 0; i < nums[0].length; i++) {
+            int maxNum = 0;
+            for (int[] num : nums) {
+                maxNum = Math.max(maxNum, num[i]);
+            }
+            score += maxNum;
+        }
+        return score;
+    }
+}

From f9edb33c4e3f06aee3698697b55b6d1a769560ea Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 May 2023 17:43:15 -0700
Subject: [PATCH 1671/2175] Update Swap Nodes in Pairs.java

---
 Medium/Swap Nodes in Pairs.java | 35 +++++++++++++++++----------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/Medium/Swap Nodes in Pairs.java b/Medium/Swap Nodes in Pairs.java
index 980e4356..505f7af0 100644
--- a/Medium/Swap Nodes in Pairs.java	
+++ b/Medium/Swap Nodes in Pairs.java	
@@ -9,22 +9,23 @@
  * }
  */
 class Solution {
-  public ListNode swapPairs(ListNode head) {
-    ListNode curr = head;
-    ListNode prev = null;
-    while (curr != null && curr.next != null) {
-      ListNode nextNode = curr.next;
-      if (curr == head) {
-        head = nextNode;
-      }
-      curr.next = nextNode.next;
-      nextNode.next = curr;
-      if (prev != null) {
-        prev.next = nextNode;
-      }
-      prev = curr;
-      curr = curr.next;
+    public ListNode swapPairs(ListNode head) {
+        ListNode curr = head;
+        ListNode prev = null;
+        while (curr != null && curr.next != null) {
+            ListNode nextNode = curr.next;
+            ListNode nextToNext = curr.next.next;
+            if (prev == null) {
+                head = nextNode;
+            } 
+            if (prev != null) {
+                prev.next = nextNode;
+            }
+            nextNode.next = curr;
+            curr.next = nextToNext;
+            prev = curr;
+            curr = nextToNext;
+        } 
+        return head;
     }
-    return head;
-  }
 }

From 922c0b01e6afac116e9d8808dc9aac4e8a283738 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 15 May 2023 18:54:08 -0700
Subject: [PATCH 1672/2175] Added Paint House II.java

---
 Hard/Paint House II.java | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Hard/Paint House II.java

diff --git a/Hard/Paint House II.java b/Hard/Paint House II.java
new file mode 100644
index 00000000..23ac7a3d
--- /dev/null
+++ b/Hard/Paint House II.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public int minCostII(int[][] costs) {
+        int n = costs.length;
+        int k = costs[0].length;
+        int[][] dp = new int[n][k];
+        for (int i = 0; i < k; i++) {
+            dp[0][i] = costs[0][i];
+        }
+        for (int i = 1; i < n; i++) {
+            for (int j = 0; j < k; j++) {
+                dp[i][j] = minCost(dp[i - 1], j) + costs[i][j];
+            }
+        }
+        return minCost(dp[n - 1], -1);
+    }
+    
+    private int minCost(int[] dp, int currPaintIdx) {
+        int cost = Integer.MAX_VALUE;
+        int idx = 0;
+        while (idx < dp.length) {
+            if (!(currPaintIdx != -1 && idx == currPaintIdx)) {
+                cost = Math.min(cost, dp[idx]);
+            }
+            idx++;
+        }
+        return cost;
+    }
+}

From b1f564ccced0d69f86be6c20718f35463b6c620b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 18 May 2023 06:29:09 -0700
Subject: [PATCH 1673/2175] Updated Minimum Number of Vertices to Reach All
 Nodes.java

---
 ...Number of Vertices to Reach All Nodes.java | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Medium/Minimum Number of Vertices to Reach All Nodes.java b/Medium/Minimum Number of Vertices to Reach All Nodes.java
index 6c0688b6..6459877d 100644
--- a/Medium/Minimum Number of Vertices to Reach All Nodes.java	
+++ b/Medium/Minimum Number of Vertices to Reach All Nodes.java	
@@ -1,15 +1,15 @@
 class Solution {
-  public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
-    int[] indegree = new int[n];
-    for (List<Integer> edge : edges) {
-      indegree[edge.get(1)]++;
+    public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
+        int[] indegree = new int[n];
+        for (List<Integer> edge : edges) {
+            indegree[edge.get(1)]++;
+        }
+        List<Integer> zeroIndegree = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                zeroIndegree.add(i);
+            }
+        }
+        return zeroIndegree;
     }
-    List<Integer> ans = new ArrayList<>();
-    for (int i = 0; i < n; i++) {
-      if (indegree[i] == 0) {
-        ans.add(i);
-      }
-    }
-    return ans;
-  }
 }

From 2773659c8c184371b3a38c632b750a9b8a995424 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 18 May 2023 18:10:31 -0700
Subject: [PATCH 1674/2175] Updated Is Graph Bipartite.java

---
 Medium/Is Graph Bipartite.java | 67 +++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 34 deletions(-)

diff --git a/Medium/Is Graph Bipartite.java b/Medium/Is Graph Bipartite.java
index c77018dc..3a30604f 100644
--- a/Medium/Is Graph Bipartite.java	
+++ b/Medium/Is Graph Bipartite.java	
@@ -1,39 +1,38 @@
 class Solution {
-  public boolean isBipartite(int[][] graph) {
-    int n = graph.length;
-    int[] color = new int[n];
-    Arrays.fill(color, -1);
-    for (int i = 0; i < n; i++) {
-      if (color[i] == -1 && !bipartiteCheck(graph, i, color)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  
-  private boolean bipartiteCheck(int[][] graph, int node, int[] color) {
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(node);
-    int currColor = 0;
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int removed = queue.remove();
-        if (color[removed] != -1) {
-          if (color[removed] != currColor) {
-            return false;
-          }
-          continue;
+    public boolean isBipartite(int[][] graph) {
+        int n = graph.length;
+        int[] color = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (color[i] == 0 && !isBipartite(graph, i, color)) {
+                return false;
+            }
         }
-        color[removed] = currColor;
-        for (int conn : graph[removed]) {
-          if (color[conn] == -1) {
-            queue.add(conn);
-          }
+        return true;
+    }
+    
+    private boolean isBipartite(int[][] graph, int node, int[] color) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(node);
+        int currColor = 1;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                if (color[removed] != 0) {
+                    if (color[removed] != currColor) {
+                        return false;
+                    }
+                } else {
+                    color[removed] = currColor;
+                    for (int conn : graph[removed]) {
+                        if (color[conn] == 0) {
+                            queue.add(conn);
+                        }
+                    }
+                }
+            }
+            currColor = currColor == 1 ? 2 : 1;
         }
-      }
-      currColor = currColor == 1 ? 0 : 1;
+        return true;
     }
-    return true;
-  }
 }

From b9301cf85ff6819780ed16c069eab7c4b2ebee9f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 20 May 2023 16:26:13 -0700
Subject: [PATCH 1675/2175] Added Sort Linked List Already Sorted Using
 Absolute Values.java

---
 ... Already Sorted Using Absolute Values.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Sort Linked List Already Sorted Using Absolute Values.java

diff --git a/Medium/Sort Linked List Already Sorted Using Absolute Values.java b/Medium/Sort Linked List Already Sorted Using Absolute Values.java
new file mode 100644
index 00000000..fd43f251
--- /dev/null
+++ b/Medium/Sort Linked List Already Sorted Using Absolute Values.java	
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode sortLinkedList(ListNode head) {
+        ListNode curr = head;
+        while (curr != null && curr.next != null){
+           if (curr.next.val < 0) {
+               // Make a new head with negative value and assign its next pointer to current head
+               head = new ListNode(curr.next.val,head);
+               curr.next = curr.next.next;
+           } else {
+                curr = curr.next;
+           }  
+        } 
+        return head; 
+    }
+}

From 42d508fa5cdec44cdd6c1de5749bba29eb11470c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 21 May 2023 06:57:45 -0700
Subject: [PATCH 1676/2175] Added Minimum String Length After Removing
 Substrings.java

---
 ...m String Length After Removing Substrings.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Minimum String Length After Removing Substrings.java

diff --git a/Easy/Minimum String Length After Removing Substrings.java b/Easy/Minimum String Length After Removing Substrings.java
new file mode 100644
index 00000000..606d3394
--- /dev/null
+++ b/Easy/Minimum String Length After Removing Substrings.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int minLength(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && c == 'B' && stack.peek() == 'A') {
+                stack.pop();
+            } else if (!stack.isEmpty() && c == 'D' && stack.peek() == 'C') {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        return stack.size();
+    }
+}

From 92c2adb93fe20993119924badbe114874240168b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 21 May 2023 11:43:16 -0700
Subject: [PATCH 1677/2175] Added Shortest Bridge.java

---
 Medium/Shortest Bridge.java | 65 +++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 Medium/Shortest Bridge.java

diff --git a/Medium/Shortest Bridge.java b/Medium/Shortest Bridge.java
new file mode 100644
index 00000000..f5194373
--- /dev/null
+++ b/Medium/Shortest Bridge.java	
@@ -0,0 +1,65 @@
+class Solution {
+    
+    private static final int[][] DIRS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+    
+    public int shortestBridge(int[][] grid) {
+        int n = grid.length;
+        int x = -1;
+        int y = -1;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 1) {
+                    x = i;
+                    y = j;
+                    break;
+                }
+            }
+        }
+        List<int[]> queueOne = new ArrayList<>();
+        List<int[]> queueTwo = new ArrayList<>();
+        queueOne.add(new int[]{x, y});
+        queueTwo.add(new int[]{x, y});
+        grid[x][y] = 2;
+        while (!queueOne.isEmpty()) {
+            List<int[]> bfs = new ArrayList<>();
+            for (int[] cell : queueOne) {
+                int currX = cell[0];
+                int currY = cell[1];
+                for (int[] dir : DIRS) {
+                    int newX = currX + dir[0];
+                    int newY = currY + dir[1];
+                    if (newX >= 0 && newX < n && newY >= 0 && newY < n && grid[newX][newY] == 1) {
+                        bfs.add(new int[]{newX, newY});
+                        queueTwo.add(new int[]{newX, newY});
+                        grid[newX][newY] = 2;
+                    }
+                }
+            }
+            queueOne = bfs;
+        }
+        int distance = 0;
+        while (!queueTwo.isEmpty()) {
+            List<int[]> bfs = new ArrayList<>();
+            for (int[] cell : queueTwo) {
+                int currX = cell[0];
+                int currY = cell[1];
+                for (int[] dir : DIRS) {
+                    int newX = currX + dir[0];
+                    int newY = currY + dir[1];
+                    if (newX >= 0 && newX < n && newY >= 0 && newY < n) {
+                        if (grid[newX][newY] == 1) {
+                            return distance;
+                        } else if (grid[newX][newY] == 0) {
+                            bfs.add(new int[]{newX, newY});
+                            grid[newX][newY] = -1;
+                        }
+                    }
+                }
+            }
+            queueTwo = bfs;
+            distance++;
+        }
+        return distance;
+    }
+}
+

From c47202023fca9448e8fb347e6f59cd9ede5ffc78 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 21 May 2023 15:41:19 -0700
Subject: [PATCH 1678/2175] Updated Minimum Size Subarray Sum.java

---
 Medium/Minimum Size Subarray Sum.java | 38 +++++++++------------------
 1 file changed, 13 insertions(+), 25 deletions(-)

diff --git a/Medium/Minimum Size Subarray Sum.java b/Medium/Minimum Size Subarray Sum.java
index 4d41780e..5bafe959 100644
--- a/Medium/Minimum Size Subarray Sum.java	
+++ b/Medium/Minimum Size Subarray Sum.java	
@@ -1,30 +1,18 @@
 class Solution {
-    public int minSubArrayLen(int s, int[] nums) {
-        int sum = 0;
-        int slow = 0;
-        int fast = 0;
-        int n = nums.length;
-        int minLen = Integer.MAX_VALUE;
-        
-        while (fast < n) {
-            sum += nums[fast];
-            
-            if (sum >= s) {
-                while (slow <= fast) {
-                    minLen = Math.min(minLen, fast - slow + 1);
-                    if (sum - nums[slow] >= s) {
-                        sum -= nums[slow];
-                        slow++;
-                    }
-                    else {
-                        break;
-                    }
-                }   
+    public int minSubArrayLen(int target, int[] nums) {
+        int start = 0;
+        int end = 0;
+        int currSum = 0;
+        int minLength = Integer.MAX_VALUE;
+        while (end < nums.length) {
+            currSum += nums[end++];
+            while (start < end && currSum - nums[start] >= target) {
+                currSum -= nums[start++];
+            }
+            if (currSum >= target) {
+                minLength = Math.min(minLength, end - start);
             }
-            
-            fast++;
         }
-        
-        return minLen == Integer.MAX_VALUE ? 0 : minLen;
+        return minLength == Integer.MAX_VALUE ? 0 : minLength;
     }
 }

From f4227494b8ce834ed98bf5609f7a6b5f4e5bf721 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 22 May 2023 16:59:29 -0700
Subject: [PATCH 1679/2175] Updated Meeting Rooms II.java

---
 Medium/Meeting Rooms II.java | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/Medium/Meeting Rooms II.java b/Medium/Meeting Rooms II.java
index d43eab4e..ff594c8a 100644
--- a/Medium/Meeting Rooms II.java	
+++ b/Medium/Meeting Rooms II.java	
@@ -1,16 +1,15 @@
 class Solution {
-  public int minMeetingRooms(int[][] intervals) {
-    Arrays.sort(intervals, Comparator.comparingInt((a) -> a[0]));
-    PriorityQueue<int[]> meetingsInProgress = new PriorityQueue<>(
-        Comparator.comparingInt((a) -> a[1]));
-    int result = 0;
-    for (int[] interval : intervals) {
-      while (!meetingsInProgress.isEmpty() && meetingsInProgress.peek()[1] <= interval[0]) {
-        meetingsInProgress.poll();
-      }
-      meetingsInProgress.add(interval);
-      result = Math.max(result, meetingsInProgress.size());
+    public int minMeetingRooms(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0]));
+        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
+        int meetingRooms = 0;
+        for (int[] interval : intervals) {
+            while (!pq.isEmpty() && pq.peek()[1] <= interval[0]) {
+                pq.poll();
+            }
+            pq.add(interval);
+            meetingRooms = Math.max(meetingRooms, pq.size());
+        }
+        return meetingRooms;
     }
-    return result;
-  }
 }

From 04bf94660422a50a0f22f94e325e2bc87630a7fb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 22 May 2023 17:16:03 -0700
Subject: [PATCH 1680/2175] Updated Kth Largest Element in a Stream.java

---
 Easy/Kth Largest Element in a Stream.java | 39 ++++++++++++-----------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/Easy/Kth Largest Element in a Stream.java b/Easy/Kth Largest Element in a Stream.java
index 30bbc6f6..4b1868f3 100644
--- a/Easy/Kth Largest Element in a Stream.java	
+++ b/Easy/Kth Largest Element in a Stream.java	
@@ -1,25 +1,28 @@
 class KthLargest {
+    
+    private final PriorityQueue<Integer> pq;
+    private final int k;
 
-  private PriorityQueue<Integer> pq;
-  private int k;
-  public KthLargest(int k, int[] nums) {
-    this.k = k;
-    this.pq = new PriorityQueue<>();
-    for (int num : nums) {
-      pq.add(num);
-      if (pq.size() > k) {
-        pq.poll();
-      }
+    public KthLargest(int k, int[] nums) {
+        this.k = k;
+        this.pq = new PriorityQueue<>((a, b) -> a - b);
+        for (int num : nums) {
+            pq.add(num);
+            checkLength();
+        }
     }
-  }
-
-  public int add(int val) {
-    pq.add(val);
-    if (pq.size() > k) {
-      pq.poll();
+    
+    public int add(int val) {
+        pq.add(val);
+        checkLength();
+        return pq.peek();
+    }
+    
+    private void checkLength() {
+        if (pq.size() > k) {
+            pq.poll();
+        }
     }
-    return pq.peek();
-  }
 }
 
 /**

From 3f9b65398725d12127e01070db7a674d5e0da1bb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 23 May 2023 07:04:36 -0700
Subject: [PATCH 1681/2175] Updated Course Schedule II.java

---
 Medium/Course Schedule II.java | 54 ++++++++++++++++++----------------
 1 file changed, 28 insertions(+), 26 deletions(-)

diff --git a/Medium/Course Schedule II.java b/Medium/Course Schedule II.java
index 78fb8e08..ce957faf 100644
--- a/Medium/Course Schedule II.java	
+++ b/Medium/Course Schedule II.java	
@@ -1,30 +1,32 @@
 class Solution {
-  public int[] findOrder(int numCourses, int[][] prerequisites) {
-    Map<Integer, List<Integer>> prerequisiteToCourseDependency = new HashMap<>();
-    int[] prerequisiteCount = new int[numCourses];
-    for (int[] prerequisite : prerequisites) {
-      prerequisiteToCourseDependency.computeIfAbsent(prerequisite[1], k -> new ArrayList<>())
-        .add(prerequisite[0]);
-      prerequisiteCount[prerequisite[0]]++;
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    for (int i = 0; i < numCourses; i++) {
-      if (prerequisiteCount[i] == 0) {
-        queue.add(i);
-      }
-    }
-    int[] courseOrder = new int[numCourses];
-    int courseOrderIdx = 0;
-    while (!queue.isEmpty()) {
-      int course = queue.remove();
-      courseOrder[courseOrderIdx++] = course;
-      for (Integer dependentCourse : prerequisiteToCourseDependency.getOrDefault(course, new ArrayList<>())) {
-        prerequisiteCount[dependentCourse]--;
-        if (prerequisiteCount[dependentCourse] == 0) {
-          queue.add(dependentCourse);
+    public int[] findOrder(int numCourses, int[][] prerequisites) {
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        int[] indegree = new int[numCourses];
+        for (int[] prerequisite : prerequisites) {
+            int course = prerequisite[0];
+            int dependency = prerequisite[1];
+            map.computeIfAbsent(dependency, k -> new HashSet<>()).add(course);
+            indegree[course]++;
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int[] result = new int[numCourses];
+        int resultIdx = 0;
+        Set<Integer> taken = new HashSet<>();
+        for (int i = 0; i < numCourses; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            result[resultIdx++] = removed;
+            for (Integer dependent : map.getOrDefault(removed, new HashSet<>())) {
+                indegree[dependent]--;
+                if (indegree[dependent] == 0) {
+                    queue.add(dependent);
+                }
+            }
         }
-      }
+        return resultIdx == numCourses ? result : new int[0];
     }
-    return courseOrderIdx == numCourses ? courseOrder : new int[]{};
-  }
 }

From b96a91203e543980b50b519db48e1bbf338c1468 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 25 May 2023 07:35:50 -0700
Subject: [PATCH 1682/2175] Added Maximum Subsequence Score.java

---
 Medium/Maximum Subsequence Score.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Maximum Subsequence Score.java

diff --git a/Medium/Maximum Subsequence Score.java b/Medium/Maximum Subsequence Score.java
new file mode 100644
index 00000000..2598f5ed
--- /dev/null
+++ b/Medium/Maximum Subsequence Score.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public long maxScore(int[] nums1, int[] nums2, int k) {
+        int[][] combined = new int[nums1.length][2];
+        for (int i = 0; i < nums1.length; i++) {
+            combined[i] = new int[]{nums1[i], nums2[i]};
+        }
+        Arrays.sort(combined, (o1, o2) -> o2[1] - o1[1]);
+        long result = 0;
+        long total = 0;
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        for (int[] unit : combined) {
+            pq.add(unit[0]);
+            total += unit[0];
+            if (pq.size() > k) {
+                total -= pq.poll();
+            }
+            if (pq.size() == k) {
+                result = Math.max(result, total * unit[1]);
+            }
+        }
+        return result;
+    }
+}

From 2c2bcd54053b58915f0dd554a16ae02bc9888f51 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 25 May 2023 10:36:00 -0700
Subject: [PATCH 1683/2175] Create New 21 Game.java

---
 Medium/New 21 Game.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/New 21 Game.java

diff --git a/Medium/New 21 Game.java b/Medium/New 21 Game.java
new file mode 100644
index 00000000..26c88d90
--- /dev/null
+++ b/Medium/New 21 Game.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public double new21Game(int n, int k, int maxPts) {
+        double[] dp = new double[n + 1];
+        dp[0] = 1;
+        double s = k > 0 ? 1 : 0;
+        for (int i = 1; i <= n; i++) {
+            dp[i] = s / maxPts;
+            if (i < k) {
+                s += dp[i];
+            }
+            if (i - maxPts >= 0 && i - maxPts < k) {
+                s -= dp[i - maxPts];
+            }
+        }
+        double result = 0;
+        for (int i = k; i <= n; i++) {
+            result += dp[i];
+        }
+        return result;
+    }
+}

From 395bd9cc3df7b83ea3dbbaf598255ae359de6db4 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 26 May 2023 07:22:44 -0700
Subject: [PATCH 1684/2175] Added Stone Game II.java

---
 Medium/Stone Game II.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Stone Game II.java

diff --git a/Medium/Stone Game II.java b/Medium/Stone Game II.java
new file mode 100644
index 00000000..c56cbd43
--- /dev/null
+++ b/Medium/Stone Game II.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int stoneGameII(int[] piles) {
+        Integer[][][] dp = new Integer[2][piles.length + 1][piles.length + 1];
+        return helper(piles, dp, 0, 0, 1);
+    }
+    
+    private int helper(int[] piles, Integer[][][] dp, int p, int i, int m) {
+        if (i == piles.length) {
+            return 0;
+        }
+        if (dp[p][i][m] != null) {
+            return dp[p][i][m];
+        }
+        int result = p == 1 ? 1000_000 : -1;
+        int s = 0;
+        for (int j = 1; j <= Math.min(2 * m, piles.length - i); j++) {
+            s += piles[i + j - 1];
+            if (p == 0) {
+                result = Math.max(result, s + helper(piles, dp, 1, i + j, Math.max(m, j)));
+            } else {
+                result = Math.min(result, helper(piles, dp, 0, i + j, Math.max(m, j)));
+            }
+        }
+        return dp[p][i][m] = result;
+    }
+}

From 1cdc4443724f72a5b10050f8ae84c76886313fb3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 27 May 2023 05:51:36 -0700
Subject: [PATCH 1685/2175] Added Stone Game III.java

---
 Hard/Stone Game III.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Hard/Stone Game III.java

diff --git a/Hard/Stone Game III.java b/Hard/Stone Game III.java
new file mode 100644
index 00000000..0ee4e539
--- /dev/null
+++ b/Hard/Stone Game III.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public String stoneGameIII(int[] stoneValue) {
+        int n = stoneValue.length;
+        int[] dp = new int[n + 1];
+        for (int i = n - 1; i >= 0; i--) {
+            dp[i] = stoneValue[i] - dp[i + 1];
+            if (i + 2 <= n) {
+                dp[i] = Math.max(dp[i], stoneValue[i] + stoneValue[i + 1] - dp[i + 2]);
+            }
+            if (i + 3 <= n) {
+                dp[i] = Math.max(dp[i], stoneValue[i] + stoneValue[i + 1] + stoneValue[i + 2] - dp[i + 3]);
+            }
+        }
+        return dp[0] == 0 ? "Tie" : (dp[0] > 0 ? "Alice" : "Bob");
+    }
+}

From 9d1391469d509648e44ac3b27eb4b3f98df0cac8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 29 May 2023 19:16:12 -0700
Subject: [PATCH 1686/2175] Added Buy Two Chocolates.java

---
 Easy/Buy Two Chocolates.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Buy Two Chocolates.java

diff --git a/Easy/Buy Two Chocolates.java b/Easy/Buy Two Chocolates.java
new file mode 100644
index 00000000..fac6699e
--- /dev/null
+++ b/Easy/Buy Two Chocolates.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int buyChoco(int[] prices, int money) {
+        int cheapestChocolate = Math.min(prices[0], prices[1]);
+        int secondCheapestChocolate = Math.max(prices[0], prices[1]);
+        for (int i = 2; i < prices.length; i++) {
+            if (prices[i] < cheapestChocolate) {
+                secondCheapestChocolate = cheapestChocolate;
+                cheapestChocolate = prices[i];
+            } else if (prices[i] < secondCheapestChocolate) {
+                secondCheapestChocolate = prices[i];
+            }
+        }
+        int totalCost = cheapestChocolate + secondCheapestChocolate;
+        return totalCost <= money ? (money - totalCost) : money;
+    }
+}

From 70fde968259d29eb444a7859b22e1d74bfc52214 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 29 May 2023 19:28:34 -0700
Subject: [PATCH 1687/2175] Added Remove Trailing Zeros From a String.java

---
 Easy/Remove Trailing Zeros From a String.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Remove Trailing Zeros From a String.java

diff --git a/Easy/Remove Trailing Zeros From a String.java b/Easy/Remove Trailing Zeros From a String.java
new file mode 100644
index 00000000..996c079e
--- /dev/null
+++ b/Easy/Remove Trailing Zeros From a String.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public String removeTrailingZeros(String num) {
+        int idx = num.length() - 1;
+        while (idx >= 0 && num.charAt(idx) == '0') {
+            idx--;
+        }
+        return num.substring(0, idx + 1);
+    }
+}

From 87cf2a510fac5e0e5d929c35fadac7d2aa6b21c7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 30 May 2023 12:13:54 -0700
Subject: [PATCH 1688/2175] Create Extra Characters in a String.java

---
 Medium/Extra Characters in a String.java | 25 ++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Extra Characters in a String.java

diff --git a/Medium/Extra Characters in a String.java b/Medium/Extra Characters in a String.java
new file mode 100644
index 00000000..4d43cc5c
--- /dev/null
+++ b/Medium/Extra Characters in a String.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int minExtraChar(String s, String[] dictionary) {
+        Integer[] dp = new Integer[s.length() + 1];
+        return helper(0, s, Arrays.stream(dictionary).collect(Collectors.toSet()), dp);
+    }
+
+    private int helper(int idx, String s, Set<String> set, Integer[] dp) {
+        if (idx == s.length()) {
+            return 0;
+        }
+        if (dp[idx] != null) {
+            return dp[idx];
+        }
+        int result = Integer.MAX_VALUE;
+        for (int i = idx; i < s.length(); i++) {
+            String sub = s.substring(idx, i + 1);
+            if (set.contains(sub)) {
+                result = Math.min(result, helper(i + 1, s, set, dp));
+            } else {
+                result = Math.min(result, i - idx + 1 + helper(i + 1, s, set, dp));
+            }
+        }
+        return dp[idx] = result;
+    }
+}

From 7f41c397e005be5d639158645155c2dadef587d1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 30 May 2023 19:41:07 -0700
Subject: [PATCH 1689/2175] Updated Design Underground System.java

---
 Medium/Design Underground System.java | 60 ++++++++++++++-------------
 1 file changed, 32 insertions(+), 28 deletions(-)

diff --git a/Medium/Design Underground System.java b/Medium/Design Underground System.java
index 51aa492a..6297656a 100644
--- a/Medium/Design Underground System.java	
+++ b/Medium/Design Underground System.java	
@@ -1,33 +1,37 @@
 class UndergroundSystem {
-  
-  private Map<String, Integer> totalTimeFromStartToEndStation;
-  private Map<String, Integer> numberOfCustomersFromStartToEndStation;
-  private Map<Integer, Integer> customerIdToStartTime;
-  private Map<Integer, String> customerIdToStartStation;
-  
-  public UndergroundSystem() {
-    this.totalTimeFromStartToEndStation = new HashMap<>();
-    this.numberOfCustomersFromStartToEndStation = new HashMap<>();
-    this.customerIdToStartTime = new HashMap<>();
-    this.customerIdToStartStation = new HashMap<>();
-  }
+    
+    private final Map<Integer, StationTimePair> customerToCheckInMapping;
+    private final Map<String, Integer> startEndStationTotalTimeMapping;
+    private final Map<String, Integer> startEndStationCountMapping;
 
-  public void checkIn(int id, String stationName, int t) {
-    this.customerIdToStartTime.put(id, t);
-    this.customerIdToStartStation.put(id, stationName);
-  }
-
-  public void checkOut(int id, String stationName, int t) {
-    int totalTime = t - this.customerIdToStartTime.get(id);
-    String key = this.customerIdToStartStation.get(id) + "|" + stationName;
-    this.totalTimeFromStartToEndStation.put(key, this.totalTimeFromStartToEndStation.getOrDefault(key, 0) + totalTime);
-    this.numberOfCustomersFromStartToEndStation.put(key, this.numberOfCustomersFromStartToEndStation.getOrDefault(key, 0) + 1);
-  }
-
-  public double getAverageTime(String startStation, String endStation) {
-    String key = startStation + "|" + endStation;
-    return this.totalTimeFromStartToEndStation.get(key) / (double) (this.numberOfCustomersFromStartToEndStation.get(key));
-   }
+    public UndergroundSystem() {
+        this.customerToCheckInMapping = new HashMap<>();
+        this.startEndStationTotalTimeMapping = new HashMap<>();
+        this.startEndStationCountMapping = new HashMap<>();
+    }
+    
+    public void checkIn(int id, String stationName, int t) {
+        StationTimePair pair = new StationTimePair(stationName, t);
+        customerToCheckInMapping.put(id, pair);
+    }
+    
+    public void checkOut(int id, String stationName, int t) {
+        StationTimePair pair = customerToCheckInMapping.get(id);
+        String key = pair.station() + "|" + stationName;
+        int totalTime = t - pair.time();
+        startEndStationTotalTimeMapping.put(key, startEndStationTotalTimeMapping.getOrDefault(key, 0) + totalTime);
+        startEndStationCountMapping.put(key, startEndStationCountMapping.getOrDefault(key, 0) + 1);
+    }
+    
+    public double getAverageTime(String startStation, String endStation) {
+        String key = startStation + "|" + endStation;
+        if (!startEndStationTotalTimeMapping.containsKey(key)) {
+            return 0.0;
+        }
+        return ((double) startEndStationTotalTimeMapping.get(key)) / startEndStationCountMapping.get(key);
+    }
+    
+    static record StationTimePair(String station, int time) {}
 }
 
 /**

From 07ed79c304efd4041119accd6c64368fae34f2f2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 31 May 2023 15:19:50 -0700
Subject: [PATCH 1690/2175] Updated Design In-Memory File System.java

---
 Hard/Design In-Memory File System.java | 216 +++++++++++++++----------
 1 file changed, 130 insertions(+), 86 deletions(-)

diff --git a/Hard/Design In-Memory File System.java b/Hard/Design In-Memory File System.java
index 9bc2ba8e..9002c758 100644
--- a/Hard/Design In-Memory File System.java	
+++ b/Hard/Design In-Memory File System.java	
@@ -1,104 +1,148 @@
+import java.util.Optional;
+
 class FileSystem {
 
-  private final FileNode root;
-
-  public FileSystem() {
-    this.root = new FileNode("ROOT", FileType.FOLDER);
-  }
-
-  /*
-   * If path is a file path, returns a list that only contains this file's name.
-   * If path is a directory path, returns the list of file and directory names in this directory.
-   * */
-  public List<String> ls(String path) {
-    String[] split = path.split("/");
-    FileNode currNode = root;
-    for (int i = 1; i < split.length; i++) {
-      currNode = currNode.subFiles.get(split[i]);
+    private final Node root;
+
+    public FileSystem() {
+        this.root = new DirectoryNode("/");
     }
-    if (currNode.fileType.equals(FileType.FILE)) {
-      return List.of(currNode.value);
-    } else {
-      return currNode.subFiles.keySet().stream().sorted().collect(Collectors.toList());
+
+    public List<String> ls(String path) {
+        String[] splits = path.split("/");
+        if (splits.length == 0) {
+            return buildlsResult((DirectoryNode) root);
+        }
+        Node curr = root;
+        for (int i = 1; i < splits.length - 1; i++) {
+            curr = ((DirectoryNode) curr).getNode(splits[i]).get();
+        }
+        Node lastNode = ((DirectoryNode) curr).getNode(splits[splits.length - 1]).get();
+        if (lastNode.isFile()) {
+            return Collections.singletonList(lastNode.getName());
+        }
+        return buildlsResult((DirectoryNode) lastNode);
     }
-  }
-
-  /*
-   * Makes a new directory according to the given path. The given directory path does not exist.
-   * If the middle directories in the path do not exist, you should create them as well.
-   * */
-  public void mkdir(String path) {
-    String[] splits = path.split("/");
-    FileNode currNode = root;
-    for (int i = 1; i < splits.length; i++) {
-      String fileName = splits[i];
-      if (!currNode.subFiles.containsKey(fileName)) {
-        currNode.subFiles.put(fileName, new FileNode(fileName, FileType.FOLDER));
-      }
-      currNode = currNode.subFiles.get(fileName);
+
+    public void mkdir(String path) {
+        String[] splits = path.split("/");
+        createIfNotExists(splits);
     }
-  }
-
-  /*
-   * If filePath does not exist, creates that file containing given content.
-   * If filePath already exists, appends the given content to original content.
-   * */
-  public void addContentToFile(String filePath, String content) {
-    String[] splits = filePath.split("/");
-    FileNode currNode = root;
-    for (int i = 1; i < splits.length - 1; i++) {
-      String folderName = splits[i];
-      if (!currNode.subFiles.containsKey(folderName)) {
-        currNode.subFiles.put(folderName, new FileNode(folderName, FileType.FOLDER));
-      }
-      currNode = currNode.subFiles.get(folderName);
+
+    public void addContentToFile(String filePath, String content) {
+        String[] splits = filePath.split("/");
+        DirectoryNode directoryNode = createIfNotExists(Arrays.copyOfRange(splits, 0, splits.length));
+        String fileName = splits[splits.length - 1];
+        if (directoryNode.getNode(fileName).isEmpty()) {
+            FileNode fileNode = new FileNode(fileName);
+            directoryNode.addContent(fileName, fileNode);
+        }
+        FileNode fileNode = (FileNode) directoryNode.getNode(fileName).get();
+        fileNode.addContent(content);
     }
-    String fileName = splits[splits.length - 1];
-    if (!currNode.subFiles.containsKey(fileName) ||
-        !currNode.subFiles.get(fileName).fileType.equals(FileType.FILE)) {
-      currNode.subFiles.put(fileName, new FileNode(fileName, FileType.FILE));
+
+    public String readContentFromFile(String filePath) {
+        String[] splits = filePath.split("/");
+        DirectoryNode directoryNode = createIfNotExists(Arrays.copyOfRange(splits, 0, splits.length));
+        String fileName = splits[splits.length - 1];
+        FileNode fileNode = (FileNode) directoryNode.getNode(fileName).get();
+        return fileNode.getContents();
     }
-    currNode = currNode.subFiles.get(fileName);
-    currNode.addContentToFile(content);
-  }
-
-  /*
-   * Returns the content in the file at filePath.
-   * */
-  public String readContentFromFile(String filePath) {
-    String[] splits = filePath.split("/");
-    FileNode currNode = root;
-    for (int i = 1; i < splits.length; i++) {
-      String folderName = splits[i];
-      currNode = currNode.subFiles.get(folderName);
+
+    private static List<String> buildlsResult(DirectoryNode curr) {
+        return curr
+                .getContents()
+                .stream()
+                .map(Node::getName)
+                .sorted()
+                .collect(Collectors.toList());
     }
-    return currNode.fileContent.toString();
-  }
 
-  enum FileType {
-    FILE, FOLDER
-  }
+    private DirectoryNode createIfNotExists(String[] splits) {
+        DirectoryNode curr = (DirectoryNode) root;
+        for (int i = 1; i < splits.length; i++) {
+            Optional<Node> nextDirectory = curr.getNode(splits[i]);
+            if (nextDirectory.isEmpty()) {
+                DirectoryNode node = new DirectoryNode(splits[i]);
+                curr.addContent(splits[i], node);
+                curr = node;
+            } else {
+                curr = (DirectoryNode) nextDirectory.get();
+            }
+        }
+        return curr;
+    }
+
+    private static class FileNode implements Node {
+
+        private final String name;
+
+        private final StringBuilder contents;
+
+        public FileNode(String name) {
+            this.name = name;
+            this.contents = new StringBuilder();
+        }
+
+        public void addContent(String content) {
+            this.contents.append(content);
+        }
 
-  static class FileNode {
+        public String getContents() {
+            return contents.toString();
+        }
 
-    private final String value;
-    private final Map<String, FileNode> subFiles;
-    private final FileType fileType;
-    private StringBuilder fileContent;
+        @Override
+        public String getName() {
+            return this.name;
+        }
 
-    public FileNode(String value, FileType fileType) {
-      this.value = value;
-      this.fileType = fileType;
-      this.subFiles = new HashMap<>();
+        @Override
+        public boolean isFile() {
+            return true;
+        }
     }
 
-    public void addContentToFile(String content) {
-      if (fileContent == null) {
-        fileContent = new StringBuilder();
-      }
-      fileContent.append(content);
+    private static class DirectoryNode implements Node {
+
+        private String name;
+
+        private final Map<String, Node> contents;
+
+        public DirectoryNode(String name) {
+            this.name = name;
+            this.contents = new HashMap<>();
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        @Override
+        public boolean isFile() {
+            return false;
+        }
+
+        public void addContent(String key, Node node) {
+            contents.put(key, node);
+        }
+
+        public List<Node> getContents() {
+            return contents.values().stream().toList();
+        }
+
+        public Optional<Node> getNode(String nodeName) {
+            return Optional.ofNullable(contents.getOrDefault(nodeName, null));
+        }
+    }
+
+    private interface Node {
+
+        String getName();
+
+        boolean isFile();
     }
-  }
 }
 
 /**

From 6ac31b58892d71863f583ab4808f7d5917cc1ce0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 1 Jun 2023 10:30:41 -0700
Subject: [PATCH 1691/2175] Updated Shortest Path in Binary Matrix.java

---
 Medium/Shortest Path in Binary Matrix.java | 67 +++++++++++-----------
 1 file changed, 35 insertions(+), 32 deletions(-)

diff --git a/Medium/Shortest Path in Binary Matrix.java b/Medium/Shortest Path in Binary Matrix.java
index 9977e11b..0be69c86 100644
--- a/Medium/Shortest Path in Binary Matrix.java	
+++ b/Medium/Shortest Path in Binary Matrix.java	
@@ -1,37 +1,40 @@
 class Solution {
-  private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
-  
-  public int shortestPathBinaryMatrix(int[][] grid) {
-    if (grid[0][0] == 1) {
-      return -1;
-    }
-    int numRows = grid.length;
-    int numCols = grid[0].length;
-    boolean[][] visited = new boolean[numRows][numCols];
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{0, 0});
-    visited[0][0] = true;
-    int numOfSteps = 0;
-    while (!queue.isEmpty()) {
-      numOfSteps++;
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        int x = removed[0];
-        int y = removed[1];
-        if (x == numRows - 1 && y == numCols - 1) {
-          return numOfSteps;
+    
+    private static final int[][] DIRS = {{0,1},{0,-1},{1,0},{-1,0},{1,-1},{-1,1},{-1,-1},{1,1}};
+    
+    public int shortestPathBinaryMatrix(int[][] grid) {
+        int numRows = grid.length;
+        int numCols = grid[0].length;
+        if (grid[0][0] == 1 || grid[numRows - 1][numCols - 1] == 1) {
+            return -1;
         }
-        for (int[] dir : DIRS) {
-          int newX = x + dir[0];
-          int newY = y + dir[1];
-          if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && !visited[newX][newY] && grid[newX][newY] == 0) {
-            queue.add(new int[]{newX, newY});
-            visited[newX][newY] = true;
-          }
+        int shortestDistance = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0});
+        boolean[][] visited = new boolean[numRows][numCols];
+        visited[0][0] = true;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                if (removed[0] == (numRows - 1) && removed[1] == (numCols - 1)) {
+                    return shortestDistance + 1;
+                }
+                for (int i = 0; i < DIRS.length; i++) {
+                    int newX = removed[0] + DIRS[i][0];
+                    int newY = removed[1] + DIRS[i][1];
+                    if (isValidCoordinate(newX, newY, numRows, numCols, visited, grid)) {
+                        queue.add(new int[]{newX, newY});
+                        visited[newX][newY] = true;
+                    }
+                }
+            }
+            shortestDistance++;
         }
-      }
+        return -1;
+    }
+    
+    private static boolean isValidCoordinate(int x, int y, int rows, int cols, boolean[][] visited, int[][] grid) {
+        return x >= 0 && x < rows && y >= 0 && y < cols && !visited[x][y] && grid[x][y] == 0;
     }
-    return -1;
-  }
 }

From c0d05f95cabf58da96bf3af333fd3e4b0a08b00a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 1 Jun 2023 19:37:00 -0700
Subject: [PATCH 1692/2175] Added Detonate the Maximum Bombs.java

---
 Medium/Detonate the Maximum Bombs.java | 37 ++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/Detonate the Maximum Bombs.java

diff --git a/Medium/Detonate the Maximum Bombs.java b/Medium/Detonate the Maximum Bombs.java
new file mode 100644
index 00000000..2dbecdc0
--- /dev/null
+++ b/Medium/Detonate the Maximum Bombs.java	
@@ -0,0 +1,37 @@
+class Solution {
+    public int maximumDetonation(int[][] bombs) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        int n = bombs.length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == j) {
+                    continue;
+                }
+                int x1 = bombs[i][0];
+                int y1 = bombs[i][1];
+                int r = bombs[i][2];
+                int x2 = bombs[j][0];
+                int y2 = bombs[j][1];
+                if ((long) r * r >= (long) (x1 - x2) * (x1 - x2) + (long) (y1 - y2) * (y1 - y2)) {
+                    graph.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
+                }
+            }
+        }
+        int result = 0;
+        for (int i = 0; i < n; i++) {
+            result = Math.max(result, dfs(i, new HashSet<>(), graph));
+        }
+        return result;
+    }
+    
+    private int dfs(int curr, Set<Integer> visited, Map<Integer, List<Integer>> graph) {
+        visited.add(curr);
+        int count = 1;
+        for (Integer neighbor : graph.getOrDefault(curr, new ArrayList<>())) {
+            if (!visited.contains(neighbor)) {
+                count += dfs(neighbor, visited, graph);
+            }
+        }
+        return count;
+    }
+}

From e97550355a8734098472d08253d9a1c15a688452 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 2 Jun 2023 17:27:07 -0700
Subject: [PATCH 1693/2175] Updated Time Needed to Inform All Employees.java

---
 .../Time Needed to Inform All Employees.java  | 41 ++++++++++---------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/Medium/Time Needed to Inform All Employees.java b/Medium/Time Needed to Inform All Employees.java
index 901f53b5..f8cc21ac 100644
--- a/Medium/Time Needed to Inform All Employees.java	
+++ b/Medium/Time Needed to Inform All Employees.java	
@@ -1,23 +1,24 @@
 class Solution {
-  public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
-    Map<Integer, List<Integer>> organization = new HashMap<>();
-    for (int i = 0; i < manager.length; i++) {
-      if (manager[i] != -1) {
-        organization.computeIfAbsent(manager[i], k -> new ArrayList<>()).add(i);
-      }
+    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
+        Map<Integer, List<Integer>> organization = new HashMap<>();
+        for (int i = 0; i < manager.length; i++) {
+            if (manager[i] == -1) {
+                continue;
+            }
+            organization.computeIfAbsent(manager[i], k -> new ArrayList<>()).add(i);
+        }
+        int maxTime = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{headID, 0});
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int currManager = removed[0];
+            int timeElapsed = removed[1];
+            maxTime = Math.max(maxTime, timeElapsed);
+            for (Integer employee : organization.getOrDefault(currManager, new ArrayList<>())) {
+                queue.add(new int[]{employee, timeElapsed + informTime[currManager]});
+            }
+        }
+        return maxTime;
     }
-    int totalTime = 0;
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{headID, 0});
-    while (!queue.isEmpty()) {
-      int[] removed = queue.remove();
-      int id = removed[0]; 
-      int time = removed[1]; 
-      totalTime = Math.max(totalTime, time);
-      for (int associate : organization.getOrDefault(id, new ArrayList<>())) {
-        queue.add(new int[]{associate, time + informTime[id]});
-      }
-    }
-    return totalTime;
-  }
 }

From 41c51ea48837dff914deaad98223e924a2d9d81b Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Jun 2023 09:00:55 -0700
Subject: [PATCH 1694/2175] Updated Number of Provinces.java

---
 Medium/Number of Provinces.java | 53 +++++++++++++++++----------------
 1 file changed, 28 insertions(+), 25 deletions(-)

diff --git a/Medium/Number of Provinces.java b/Medium/Number of Provinces.java
index 4f485f0d..03338dd8 100644
--- a/Medium/Number of Provinces.java	
+++ b/Medium/Number of Provinces.java	
@@ -1,34 +1,37 @@
 class Solution {
-  public int findCircleNum(int[][] isConnected) {
-    int n = isConnected.length;
-    Map<Integer, Set<Integer>> map = new HashMap<>();
-    for (int i = 0; i < n; i++) {
-      for (int j = 0; j < n; j++) {
-        if (i != j && isConnected[i][j] == 1) {
-          map.computeIfAbsent(i, k -> new HashSet<>()).add(j);
-          map.computeIfAbsent(j, k -> new HashSet<>()).add(i);
+    public int findCircleNum(int[][] isConnected) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < isConnected.length; i++) {
+            for (int j = 0; j < isConnected[i].length; j++) {
+                if (i != j && isConnected[i][j] == 1) {
+                    graph.computeIfAbsent(i, k -> new HashSet<>()).add(j);
+                    graph.computeIfAbsent(j, k -> new HashSet<>()).add(i);
+                }
+            }
+        }
+        Set<Integer> visited = new HashSet<>();
+        int provinces = 0;
+        for (int i = 0; i < isConnected.length; i++) {
+            if (!visited.contains(i)) {
+                traverse(graph, i, visited);
+                provinces++;
+            }
         }
-      }
+        return provinces;
     }
-    Set<Integer> visited = new HashSet<>();
-    int provinceCount = 0;
-    for (int i = 0; i < n; i++) {
-      if (!visited.contains(i)) {
+    
+    private void traverse(Map<Integer, Set<Integer>> graph, int city, Set<Integer> visited) {
         Queue<Integer> queue = new LinkedList<>();
-        queue.add(i);
-        visited.add(i);
+        queue.add(city);
+        visited.add(city);
         while (!queue.isEmpty()) {
-          int removed = queue.remove();
-          for (Integer connection : map.getOrDefault(removed, new HashSet<>())) {
-            if (!visited.contains(connection)) {
-              queue.add(connection);
-              visited.add(connection);
+            int removed = queue.remove();
+            for (Integer conn : graph.getOrDefault(removed, new HashSet<>())) {
+                if (!visited.contains(conn)) {
+                    queue.add(conn);
+                    visited.add(conn);
+                }
             }
-          }
         }
-        provinceCount++;
-      }
     }
-    return provinceCount;
-  }
 }

From 53848d3486110031e8e5feb963e43fe47437c0f6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Jun 2023 09:05:04 -0700
Subject: [PATCH 1695/2175] Added Minimize String Length.java

---
 Easy/Minimize String Length.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Minimize String Length.java

diff --git a/Easy/Minimize String Length.java b/Easy/Minimize String Length.java
new file mode 100644
index 00000000..1cb68cf5
--- /dev/null
+++ b/Easy/Minimize String Length.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int minimizedStringLength(String s) {
+        return s.chars()
+            .mapToObj(c -> (char) c)
+            .collect(Collectors.toSet())
+            .size();
+    }
+}

From 5bbc5c666894ea1f8dcfca0f076bee9a059b35a7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Jun 2023 09:06:05 -0700
Subject: [PATCH 1696/2175] Updated Minimize String Length.java

---
 Easy/Minimize String Length.java | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/Easy/Minimize String Length.java b/Easy/Minimize String Length.java
index 1cb68cf5..48d8ab26 100644
--- a/Easy/Minimize String Length.java	
+++ b/Easy/Minimize String Length.java	
@@ -1,8 +1,7 @@
 class Solution {
     public int minimizedStringLength(String s) {
-        return s.chars()
-            .mapToObj(c -> (char) c)
-            .collect(Collectors.toSet())
-            .size();
+        return (int) s.chars()
+            .distinct()
+            .count();
     }
 }

From 22816322b7409e183ae7ff211e9f26b25dd57394 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 4 Jun 2023 17:37:24 -0700
Subject: [PATCH 1697/2175] Updated Check If It Is a Straight Line.java

---
 Easy/Check If It Is a Straight Line.java | 33 ++++++++++++++----------
 1 file changed, 19 insertions(+), 14 deletions(-)

diff --git a/Easy/Check If It Is a Straight Line.java b/Easy/Check If It Is a Straight Line.java
index 174053a3..407ed220 100644
--- a/Easy/Check If It Is a Straight Line.java	
+++ b/Easy/Check If It Is a Straight Line.java	
@@ -1,16 +1,21 @@
-class Solution {
-  public boolean checkStraightLine(int[][] coordinates) {
-    int xOne = coordinates[1][0]; 
-    int yOne = coordinates[1][1];
-    int dx = xOne - coordinates[0][0];
-    int dy = yOne - coordinates[0][1];
-    for (int[] coordinate : coordinates) {
-      int x = coordinate[0];
-      int y = coordinate[1];
-      if (dx * (y - yOne) != dy * (x - xOne)) {
-        return false;
-      }
+class Solution {    
+    public boolean checkStraightLine(int[][] coordinates) {
+        int deltaY = getYDiff(coordinates[1], coordinates[0]);
+        int deltaX = getXDiff(coordinates[1], coordinates[0]);
+        for (int i = 2; i < coordinates.length; i++) {
+            if (deltaY * getXDiff(coordinates[i], coordinates[0]) != deltaX * getYDiff(coordinates[i], coordinates[0])) {
+                return false;
+            }
+        }
+        return true;
     }
-    return true;
-  }
+    
+    private int getYDiff(int[] a, int[] b) {
+        return a[1] - b[1];
+    }
+
+    private int getXDiff(int[] a, int[] b) {
+        return a[0] - b[0];
+    }
+
 }

From 7cf26a8577ef68df23c38a949b4b006cb630a76a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 5 Jun 2023 18:01:50 -0700
Subject: [PATCH 1698/2175] Updated Can Make Arithmetic Progression From
 Sequence.java

---
 ...e Arithmetic Progression From Sequence.java | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Easy/Can Make Arithmetic Progression From Sequence.java b/Easy/Can Make Arithmetic Progression From Sequence.java
index edc5b0db..fbd09e98 100644
--- a/Easy/Can Make Arithmetic Progression From Sequence.java	
+++ b/Easy/Can Make Arithmetic Progression From Sequence.java	
@@ -1,12 +1,12 @@
 class Solution {
-  public boolean canMakeArithmeticProgression(int[] arr) {
-    Arrays.sort(arr);
-    int diff = arr[1] - arr[0];
-    for (int i = 2; i < arr.length; i++) {
-      if (arr[i] - arr[i - 1] != diff) {
-        return false;
-      }
+    public boolean canMakeArithmeticProgression(int[] arr) {
+        Arrays.sort(arr);
+        int diff = arr[1] - arr[0];
+        for (int i = 2; i < arr.length; i++) {
+            if (arr[i] - arr[i - 1] != diff) {
+                return false;
+            }
+        }
+        return true;
     }
-    return true;
-  }
 }

From eeefb09a22ea781114971952f1e1108d6571ebc8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 6 Jun 2023 17:53:14 -0700
Subject: [PATCH 1699/2175] Added Minimum Flips to Make a OR b Equal to c.java

---
 Medium/Minimum Flips to Make a OR b Equal to c.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Medium/Minimum Flips to Make a OR b Equal to c.java

diff --git a/Medium/Minimum Flips to Make a OR b Equal to c.java b/Medium/Minimum Flips to Make a OR b Equal to c.java
new file mode 100644
index 00000000..91963256
--- /dev/null
+++ b/Medium/Minimum Flips to Make a OR b Equal to c.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int minFlips(int a, int b, int c) {
+        return Integer.bitCount((a | b) ^ c) + Integer.bitCount(a & b & ((a | b) ^ c)); 
+    }
+}

From c94158c3aa2b810811be68c90d1ea4fd3bce7271 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Jun 2023 17:30:39 -0700
Subject: [PATCH 1700/2175] Update Count Negative Numbers in a Sorted
 Matrix.java

---
 ...t Negative Numbers in a Sorted Matrix.java | 46 +++++++++----------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/Easy/Count Negative Numbers in a Sorted Matrix.java b/Easy/Count Negative Numbers in a Sorted Matrix.java
index 96daf80b..af842b43 100644
--- a/Easy/Count Negative Numbers in a Sorted Matrix.java	
+++ b/Easy/Count Negative Numbers in a Sorted Matrix.java	
@@ -1,28 +1,26 @@
 class Solution {
-  public int countNegatives(int[][] grid) {
-    int total = 0;
-    int n = grid[0].length;
-    for (int[] gr : grid) {
-      int negInd = binarySearchHelper(gr, 0, n - 1);
-      if (negInd != -1) {
-        total += n - negInd;
-      }
+    public int countNegatives(int[][] grid) {
+        int count = 0;
+        for (int[] row : grid) {
+            int idx = findFirstNonNegativeIndex(row);
+            count += idx == -1 ? 0 : (row.length - idx);
+        }
+        return count;
     }
-    return total;
-  }
-  
-  private int binarySearchHelper(int[] arr, int start, int end) {
-    int idx = -1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (arr[mid] < 0) {
-        idx = idx == -1 ? mid : Math.min(idx, mid);
-        end = mid - 1;
-      }
-      if (arr[mid] >= 0) {
-        start = mid + 1;
-      }
+    
+    private int findFirstNonNegativeIndex(int[] row) {
+        int start = 0;
+        int end = row.length - 1;
+        int idx = -1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (row[mid] < 0) {
+                idx = mid;
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return idx;
     }
-    return idx;
-  }
 }

From 92994b4fec8f27c58c77b21afd7272bcba76fa22 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 8 Jun 2023 07:40:52 -0700
Subject: [PATCH 1701/2175] Updated Check If a Number Is Majority Element in a
 Sorted Array.java

---
 ...Is Majority Element in a Sorted Array.java | 66 +++++++++----------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/Easy/Check If a Number Is Majority Element in a Sorted Array.java b/Easy/Check If a Number Is Majority Element in a Sorted Array.java
index 5913a03a..6491d715 100644
--- a/Easy/Check If a Number Is Majority Element in a Sorted Array.java	
+++ b/Easy/Check If a Number Is Majority Element in a Sorted Array.java	
@@ -1,38 +1,38 @@
 class Solution {
-  
-  private static enum DIRECTION {
-    LEFT, RIGHT;
-  }
-  
-  public boolean isMajorityElement(int[] nums, int target) {
-    int rightIdx = getIndex(nums, target, DIRECTION.RIGHT);
-    int leftIdx = getIndex(nums, target, DIRECTION.LEFT);
-    if (leftIdx == -1 || rightIdx == -1) {
-      return false;
+    
+    private static enum Direction {
+        LEFT, RIGHT;
     }
-    int occurrences = rightIdx - leftIdx + 1;
-    return occurrences > nums.length / 2;
-  }
-  
-  private int getIndex(int[] nums, int target, DIRECTION direction) {
-    int resultIdx = -1;
-    int left = 0;
-    int right = nums.length - 1;
-    while (left <= right) {
-      int mid = (left + right) / 2;
-      if (nums[mid] == target) {
-        resultIdx = mid;
-        if (direction == DIRECTION.LEFT) {
-          right = mid - 1;
-        } else {
-          left = mid + 1;
+    
+    public boolean isMajorityElement(int[] nums, int target) {
+        int firstIndex = findIndex(nums, target, Direction.LEFT);
+        if (firstIndex == -1) {
+            return false;
         }
-      } else if (nums[mid] > target) {
-        right = mid - 1;
-      } else {
-        left = mid + 1;
-      }
+        int lastIndex = findIndex(nums, target, Direction.RIGHT);
+        int occurrences = lastIndex - firstIndex + 1;
+        return occurrences > nums.length / 2;
+    }
+
+    private int findIndex(int[] nums, int target, Direction direction) {
+        int idx = -1;
+        int start = 0;
+        int end = nums.length - 1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (nums[mid] == target) {
+                idx = mid;
+                if (direction == Direction.LEFT) {
+                    end = mid - 1;
+                } else {
+                    start = mid + 1;
+                }
+            } else if (nums[mid] > target) {
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return idx;
     }
-    return resultIdx;
-  }
 }

From 97c6f39986bab73e050b2e6db1acdba366adc65d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 8 Jun 2023 14:37:39 -0700
Subject: [PATCH 1702/2175] Updated Merge Intervals.java

---
 Medium/Merge Intervals.java | 34 +++++++++++++++-------------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/Medium/Merge Intervals.java b/Medium/Merge Intervals.java
index c4b49872..cb0a90cf 100644
--- a/Medium/Merge Intervals.java	
+++ b/Medium/Merge Intervals.java	
@@ -1,22 +1,18 @@
 class Solution {
-  public int[][] merge(int[][] intervals) {
-    Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1]));
-    List<int[]> mergedIntervals = new ArrayList<>();
-    int idx = 0;
-    while (idx < intervals.length) {
-      int currentStart = intervals[idx][0];
-      int currentEnd = intervals[idx][1];
-      idx++;
-      while (idx < intervals.length && intervals[idx][0] <= currentEnd) {
-        currentEnd = Math.max(intervals[idx][1], currentEnd);
-        idx++;
-      }
-      mergedIntervals.add(new int[]{currentStart, currentEnd});
+    public int[][] merge(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0])
+                .thenComparingInt(o -> o[1]));
+        int idx = 0;
+        List<int[]> result = new ArrayList<>();
+        while (idx < intervals.length) {
+            int start = intervals[idx][0];
+            int end = intervals[idx][1];
+            idx++;
+            while (idx < intervals.length && intervals[idx][0] <= end) {
+                end = Math.max(end, intervals[idx++][1]);
+            }
+            result.add(new int[]{start, end});
+        }
+        return result.toArray(new int[][]{});
     }
-    int[][] result = new int[mergedIntervals.size()][2];
-    for (int i = 0; i < mergedIntervals.size(); i++) {
-      result[i] = mergedIntervals.get(i);
-    }
-    return result;
-  }
 }

From 0a29fb631d6454d8a29dbc42443b6f9449fe9eec Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 8 Jun 2023 18:56:07 -0700
Subject: [PATCH 1703/2175] Updated Find Smallest Letter Greater Than
 Target.java

---
 ...d Smallest Letter Greater Than Target.java | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Easy/Find Smallest Letter Greater Than Target.java b/Easy/Find Smallest Letter Greater Than Target.java
index 62e6cf03..6cdfb73a 100644
--- a/Easy/Find Smallest Letter Greater Than Target.java	
+++ b/Easy/Find Smallest Letter Greater Than Target.java	
@@ -1,17 +1,17 @@
 class Solution {
-  public char nextGreatestLetter(char[] letters, char target) {
-    int start = 0;
-    int end = letters.length - 1;
-    int minIdx = Integer.MAX_VALUE;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (letters[mid] > target) {
-        minIdx = mid;
-        end = mid - 1;
-      } else {
-        start = mid + 1;
-      }
+    public char nextGreatestLetter(char[] letters, char target) {
+        int start = 0;
+        int end = letters.length - 1;
+        int idx = -1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (letters[mid] > target) {
+                idx = mid;
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return idx == -1 ? letters[0] : letters[idx];
     }
-    return minIdx == Integer.MAX_VALUE ? letters[0] : letters[minIdx];
-  }
 }

From 1a6187b29dc66de08415de45c9c945093c45d679 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 10 Jun 2023 12:23:32 -0700
Subject: [PATCH 1704/2175] Added Maximum Value at a Given Index in a Bounded
 Array.java

---
 ...e at a Given Index in a Bounded Array.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Medium/Maximum Value at a Given Index in a Bounded Array.java

diff --git a/Medium/Maximum Value at a Given Index in a Bounded Array.java b/Medium/Maximum Value at a Given Index in a Bounded Array.java
new file mode 100644
index 00000000..6a1a4966
--- /dev/null
+++ b/Medium/Maximum Value at a Given Index in a Bounded Array.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int maxValue(int n, int index, int maxSum) {
+        int start = 1;
+        int end = maxSum;
+        while (start < end) {
+            int mid = (start + end + 1) / 2;
+            if (findSum(index, mid, n) <= maxSum) {
+                start = mid;
+            } else {
+                end = mid - 1;
+            }
+        }
+        return start;
+    }
+    
+    private long findSum(int index, int targetIndex, int n) {
+        long count = 0;
+        if (targetIndex > index) {
+            count += (long) (2 * targetIndex - index) * (index + 1) / 2;
+        } else {
+            count += (long) (targetIndex + 1) * targetIndex / 2 + index - targetIndex + 1;
+        }
+        if (targetIndex >= n - index) {
+            count += (long) (targetIndex + targetIndex - n + 1 + index) * (n - index) / 2;
+        } else {
+            count += (long) (targetIndex + 1) * targetIndex / 2 + n - index - targetIndex;
+        }   
+        return count - targetIndex;
+    }
+}

From 4cad923b9990fcc55edc26e2a5dee70d6214fe39 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 10 Jun 2023 13:29:57 -0700
Subject: [PATCH 1705/2175] Added Check if The Number is Fascinating.java

---
 Easy/Check if The Number is Fascinating.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Check if The Number is Fascinating.java

diff --git a/Easy/Check if The Number is Fascinating.java b/Easy/Check if The Number is Fascinating.java
new file mode 100644
index 00000000..d5074568
--- /dev/null
+++ b/Easy/Check if The Number is Fascinating.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public boolean isFascinating(int n) {
+        return isFascinatingHelper(n + "" + 2 * n + "" + 3 * n);
+    }
+    
+    private boolean isFascinatingHelper(String s) {
+        return s.length() == 9 && s.chars()
+            .mapToObj(c -> (char)  c)
+            .filter(c -> c != '0')
+            .collect(Collectors.toSet())
+            .size() == 9;
+    }
+}

From a7951290fddcdf8dc5c911c6d3513d9c54abd1bd Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 10 Jun 2023 17:49:47 -0700
Subject: [PATCH 1706/2175] Added Find the Longest Semi-Repetitive
 Substring.java

---
 ...the Longest Semi-Repetitive Substring.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Find the Longest Semi-Repetitive Substring.java

diff --git a/Medium/Find the Longest Semi-Repetitive Substring.java b/Medium/Find the Longest Semi-Repetitive Substring.java
new file mode 100644
index 00000000..f6743a56
--- /dev/null
+++ b/Medium/Find the Longest Semi-Repetitive Substring.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int longestSemiRepetitiveSubstring(String s) {
+        int start = 0;
+        int end = 0;
+        int maxLength = 1;
+        int consecutiveCount = 0;
+        while (end < s.length() - 1) {
+            if (s.charAt(end) == s.charAt(end + 1)) {
+                consecutiveCount++;
+            }
+            end++;
+            while (start < end && consecutiveCount > 1) {
+                if (s.charAt(start) == s.charAt(start + 1)) {
+                    consecutiveCount--;
+                }
+                start++;
+            }
+            maxLength = Math.max(maxLength, end - start + 1);
+        }
+        return maxLength;
+    }
+}

From 220e3c191fe32bb28493aaabc9560ab2af7ebd19 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 11 Jun 2023 09:21:03 -0700
Subject: [PATCH 1707/2175] Added Neither Minimum nor Maximum.java

---
 Easy/Neither Minimum nor Maximum.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Neither Minimum nor Maximum.java

diff --git a/Easy/Neither Minimum nor Maximum.java b/Easy/Neither Minimum nor Maximum.java
new file mode 100644
index 00000000..b5d7a6d1
--- /dev/null
+++ b/Easy/Neither Minimum nor Maximum.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int findNonMinOrMax(int[] nums) {
+        int min = nums[0];   
+        int max = nums[0];
+        for (int num : nums) {
+            min = Math.min(num, min);
+            max = Math.max(num, max);
+        }
+        final int arrayMin = min;
+        final int arrayMax = max;
+        return Arrays.stream(nums)
+            .filter(num -> num != arrayMin && num != arrayMax)
+            .findFirst()
+            .orElse(-1);
+    }
+}

From c9e15169f169737873777053a1a78a7fc14395db Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 11 Jun 2023 09:30:22 -0700
Subject: [PATCH 1708/2175] Added Lexicographically Smallest String After
 Substring Operation.java

---
 ...lest String After Substring Operation.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Lexicographically Smallest String After Substring Operation.java

diff --git a/Medium/Lexicographically Smallest String After Substring Operation.java b/Medium/Lexicographically Smallest String After Substring Operation.java
new file mode 100644
index 00000000..e55990b7
--- /dev/null
+++ b/Medium/Lexicographically Smallest String After Substring Operation.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public String smallestString(String s) {
+        StringBuilder sb = new StringBuilder();
+        int idx = 0;
+        while (idx < s.length() && s.charAt(idx) == 'a') {
+            sb.append(s.charAt(idx++));
+        }
+        if (idx == s.length()) {
+            return s.substring(0, s.length() - 1) + 'z';
+        }
+        while (idx < s.length() && s.charAt(idx) != 'a') {
+            sb.append(getPreviousChar(s.charAt(idx++)));
+        }
+        return sb.append(s.substring(idx)).toString();
+    }
+    
+    private char getPreviousChar(char c) {
+        return (char) (c - 1);
+    }
+}

From e84f8856b088683a88b430fca9a548e927ae1fa2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 11 Jun 2023 09:48:01 -0700
Subject: [PATCH 1709/2175] Updated Longest Palindromic Substring.java

---
 Medium/Longest Palindromic Substring.java | 46 ++++++++++++-----------
 1 file changed, 25 insertions(+), 21 deletions(-)

diff --git a/Medium/Longest Palindromic Substring.java b/Medium/Longest Palindromic Substring.java
index c22fec2d..73732212 100644
--- a/Medium/Longest Palindromic Substring.java	
+++ b/Medium/Longest Palindromic Substring.java	
@@ -1,24 +1,28 @@
 class Solution {
-  public String longestPalindrome(String s) {
-    int start = 0;
-    int end = 0;
-    for (int i = 0; i < s.length(); i++) {
-      int lenOne = helper(s, i, i);
-      int lenTwo = helper(s, i, i + 1);
-      int maxLength = Math.max(lenOne, lenTwo);
-      if (maxLength > end - start) {
-        start = i - (maxLength - 1) / 2;
-        end = i + maxLength / 2;
-      }
+    public String longestPalindrome(String s) {
+        int n = s.length();
+        boolean[][] dp = new boolean[n][n];
+        int[] result = new int[]{0, 0};
+        for (int i = 0; i < n; i++) {
+            dp[i][i] = true;
+        }
+        for (int i = 0; i < n - 1; i++) {
+            if (s.charAt(i) == s.charAt(i + 1)) {
+                dp[i][i + 1] = true;
+                result[0] = i;
+                result[1] = i + 1;
+            }
+        }
+        for (int i = 2; i < n; i++) {
+            for (int j = 0; j < n - i; j++) {
+                int k = i + j;
+                if (s.charAt(j) == s.charAt(k) && dp[j + 1][k - 1]) {
+                    dp[j][k] = true;
+                    result[0] = j;
+                    result[1] = k;
+                }
+            }
+        }
+        return s.substring(result[0], result[1] + 1);
     }
-    return s.substring(start, end + 1);
-  }
-  
-  private int helper(String s, int left, int right) {
-    while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
-      left--;
-      right++;
-    }
-    return right - left - 1;
-  }
 }

From 87898047e5d7f922a44f6fe01f676ba49aa1fced Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 12 Jun 2023 06:41:03 -0700
Subject: [PATCH 1710/2175] Updated Summary Ranges.java

---
 Easy/Summary Ranges.java | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/Easy/Summary Ranges.java b/Easy/Summary Ranges.java
index cf67a700..0de1dc7b 100644
--- a/Easy/Summary Ranges.java	
+++ b/Easy/Summary Ranges.java	
@@ -1,18 +1,16 @@
 class Solution {
-  public List<String> summaryRanges(int[] nums) {
-    List<String> result = new ArrayList<>();
-    int idx = 0;
-    int n = nums.length;
-    while (idx < n) {
-      int start = nums[idx];
-      int end = start;
-      idx++;
-      while (idx < n && nums[idx] == end + 1) {
-        end = nums[idx];
-        idx++;
-      }
-      result.add(start == end ? String.valueOf(start) : (start + "->" + end));
+    public List<String> summaryRanges(int[] nums) {
+        List<String> result = new ArrayList<>();
+        int idx = 0;
+        while (idx < nums.length) {
+            int startIdx = idx;
+            int endIdx = idx;
+            idx++;
+            while (idx < nums.length && nums[idx] - nums[idx - 1] == 1) {
+                endIdx = idx++;
+            }
+            result.add(startIdx == endIdx ? String.valueOf(nums[startIdx]) : nums[startIdx] + "->" + nums[endIdx]);
+        }
+        return result;
     }
-    return result;
-  }
 }

From c2cd62e5dce249eb8126ff5fc47fd2eef8de1f37 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 12 Jun 2023 17:17:06 -0700
Subject: [PATCH 1711/2175] Updated Equal Row and Column Pairs.java

---
 Medium/Equal Row and Column Pairs.java | 42 ++++++++++++--------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/Medium/Equal Row and Column Pairs.java b/Medium/Equal Row and Column Pairs.java
index 7c31eb66..515fb2db 100644
--- a/Medium/Equal Row and Column Pairs.java	
+++ b/Medium/Equal Row and Column Pairs.java	
@@ -1,25 +1,23 @@
 class Solution {
-  public int equalPairs(int[][] grid) {
-    Map<String, Integer> map = new HashMap<>();
-    int rows = grid.length;
-    int cols = grid[0].length;
-    for (int i = 0; i < rows; i++) {
-      StringBuilder sb = new StringBuilder();
-      for (int j = 0; j < cols; j++) {
-        sb.append(grid[i][j]).append("|");
-      }
-      String key = sb.toString();
-      map.put(key, map.getOrDefault(key, 0) + 1);
+    public int equalPairs(int[][] grid) {
+        Map<String, Integer> rowMap = new HashMap<>();
+        for (int[] value : grid) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < grid[0].length; j++) {
+                sb.append(value[j]).append("|");
+            }
+            String key = sb.toString();
+            rowMap.put(key, rowMap.getOrDefault(key, 0) + 1);
+        }
+        int count = 0;
+        for (int i = 0; i < grid[0].length; i++) {
+            StringBuilder sb = new StringBuilder();
+            for (int[] ints : grid) {
+                sb.append(ints[i]).append("|");
+            }
+            String key = sb.toString();
+            count += rowMap.getOrDefault(key, 0);
+        }
+        return count;
     }
-    int count = 0;
-    for (int i = 0; i < cols; i++) {
-      StringBuilder sb = new StringBuilder();
-      for (int j = 0; j < rows; j++) {
-        sb.append(grid[j][i]).append("|");
-      }
-      String key = sb.toString();
-      count += map.getOrDefault(key, 0);
-    }
-    return count;
-  }
 }

From 9568033f2a62dbc2c4944975e6802b6baa0d04d6 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 13 Jun 2023 17:53:49 -0700
Subject: [PATCH 1712/2175] Updated Minimum  Absolute Difference in BST.java

---
 Easy/Minimum  Absolute Difference in BST.java | 34 +++++++++----------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/Easy/Minimum  Absolute Difference in BST.java b/Easy/Minimum  Absolute Difference in BST.java
index d29da542..80248dc1 100644
--- a/Easy/Minimum  Absolute Difference in BST.java	
+++ b/Easy/Minimum  Absolute Difference in BST.java	
@@ -14,24 +14,22 @@
  * }
  */
 class Solution {
-  int minDiff;
-  TreeNode prev;
-  public int getMinimumDifference(TreeNode root) {
-    minDiff = Integer.MAX_VALUE;
-    prev = null;
-    helper(root);
-    return minDiff;
-  }
-  
-  private void helper(TreeNode root) {
-    if (root == null) {
-      return;
+    public int getMinimumDifference(TreeNode root) {
+        List<Integer> nodeValues = new ArrayList<>();
+        inorder(root, nodeValues);
+        int minDifference = Integer.MAX_VALUE;
+        for (int i = 1; i < nodeValues.size(); i++) {
+            minDifference = Math.min(minDifference, nodeValues.get(i) - nodeValues.get(i - 1));
+        }
+        return minDifference;
     }
-    helper(root.left);
-    if (prev != null) {
-      minDiff = Math.min(minDiff, Math.abs(root.val - prev.val));
+
+    private void inorder(TreeNode root, List<Integer> nodeValues) {
+        if (root == null) {
+            return;
+        }
+        inorder(root.left, nodeValues);
+        nodeValues.add(root.val);
+        inorder(root.right, nodeValues);
     }
-    prev = root;
-    helper(root.right);
-  }
 }

From 5ff595191ff7e7e91b006010218ea4a4703473f9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 14 Jun 2023 17:10:20 -0700
Subject: [PATCH 1713/2175] Updated Maximum Level Sum of a Binary Tree.java

---
 .../Maximum Level Sum of a Binary Tree.java   | 53 +++++++++----------
 1 file changed, 25 insertions(+), 28 deletions(-)

diff --git a/Medium/Maximum Level Sum of a Binary Tree.java b/Medium/Maximum Level Sum of a Binary Tree.java
index 8c1bdac6..74c62767 100644
--- a/Medium/Maximum Level Sum of a Binary Tree.java	
+++ b/Medium/Maximum Level Sum of a Binary Tree.java	
@@ -14,34 +14,31 @@
  * }
  */
 class Solution {
-  public int maxLevelSum(TreeNode root) {
-    if (root == null) {
-      return 0;
-    }
-    int currLevel = 1;
-    int maxSum = Integer.MIN_VALUE;
-    int maxSumLevel = 0;
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      int currSum = 0;
-      while (size-- > 0) {
-        TreeNode removed = queue.remove();
-        currSum += removed.val;
-        if (removed.left != null) {
-          queue.add(removed.left);
-        }
-        if (removed.right != null) {
-          queue.add(removed.right);
+    public int maxLevelSum(TreeNode root) {
+        int maxSum = Integer.MIN_VALUE;
+        int maxSumLevel = 0;
+        int currLevel = 1;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int levelSum = 0;
+            int size = queue.size();
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                levelSum += removed.val;
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            if (levelSum > maxSum) {
+                maxSum = levelSum;
+                maxSumLevel = currLevel;
+            }
+            currLevel++;
         }
-      }
-      if (maxSum < currSum) {
-        maxSum = currSum;
-        maxSumLevel = currLevel;
-      }
-      currLevel++;
+        return maxSumLevel;
     }
-    return maxSumLevel;
-  }
 }

From 82a1e5fe9c7d6abb761ad6ebaf75e41482092ef3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 15 Jun 2023 17:10:51 -0700
Subject: [PATCH 1714/2175] Added Number of Ways to Reorder Array to Get Same
 BST.java

---
 ...Ways to Reorder Array to Get Same BST.java | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Hard/Number of Ways to Reorder Array to Get Same BST.java

diff --git a/Hard/Number of Ways to Reorder Array to Get Same BST.java b/Hard/Number of Ways to Reorder Array to Get Same BST.java
new file mode 100644
index 00000000..a47c1f1d
--- /dev/null
+++ b/Hard/Number of Ways to Reorder Array to Get Same BST.java	
@@ -0,0 +1,38 @@
+class Solution {
+    
+    private static final long MOD = 1000_000_007;
+    
+    public int numOfWays(int[] nums) {
+        int n = nums.length;
+        long[][] dp = new long[n][n];
+        for (int i = 0; i < n; i++) {
+            dp[i][0] = dp[i][i] = 1; 
+        }
+        for (int i = 2; i < n; i++) {
+            for (int j = 1; j < i; j++) {
+                dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % MOD;
+            }
+        }
+        List<Integer> list = Arrays.stream(nums).boxed().collect(Collectors.toList());
+        return (int) ((dfs(list, dp) - 1) % MOD);
+    }
+    
+    private long dfs(List<Integer> nums, long[][] dp) {
+        int n = nums.size();
+        if (n < 3) {
+            return 1;
+        }
+        List<Integer> leftNodes = new ArrayList<>();
+        List<Integer> rightNodes = new ArrayList<>();
+        for (int i = 1; i < n; i++) {
+            if (nums.get(i) < nums.get(0)) {
+                leftNodes.add(nums.get(i));
+            } else {
+                rightNodes.add(nums.get(i));
+            }
+        }
+        long leftCount = dfs(leftNodes, dp) % MOD;
+        long rightCount = dfs(rightNodes, dp) % MOD;
+        return (((leftCount * rightCount) % MOD) * dp[n - 1][leftNodes.size()]) % MOD;
+    }
+}

From c294d1945c617cd2a1e8c8c1fbade7390fe2f4b0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 17 Jun 2023 07:19:29 -0700
Subject: [PATCH 1715/2175] Added Make Array Strictly Increasing.java

---
 Hard/Make Array Strictly Increasing.java | 41 ++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Hard/Make Array Strictly Increasing.java

diff --git a/Hard/Make Array Strictly Increasing.java b/Hard/Make Array Strictly Increasing.java
new file mode 100644
index 00000000..77bed2a8
--- /dev/null
+++ b/Hard/Make Array Strictly Increasing.java	
@@ -0,0 +1,41 @@
+class Solution {
+    public int makeArrayIncreasing(int[] arr1, int[] arr2) {
+        Arrays.sort(arr2);
+        Map<Pair<Integer, Integer>, Integer> dp = new HashMap<>();
+        int result = dfs(0, -1, arr1, arr2, dp);
+        return result < 2001 ? result : -1;
+    }
+    
+    private int dfs(int idx, int prev, int[] arr1, int[] arr2, Map<Pair<Integer, Integer>, Integer> dp) {
+        if (idx == arr1.length) {
+            return 0;
+        }
+        if (dp.containsKey(new Pair<>(idx, prev))) {
+            return dp.get(new Pair<>(idx, prev));
+        }
+        int cost = 2001;
+        if (arr1[idx] > prev) {
+            cost = dfs(idx + 1, arr1[idx], arr1, arr2, dp);
+        }
+        int replaceIdx = binarySearch(arr2, prev);
+        if (replaceIdx < arr2.length) {
+            cost = Math.min(cost, 1 + dfs(idx + 1, arr2[replaceIdx], arr1, arr2, dp));
+        }
+        dp.put(new Pair<>(idx, prev), cost);
+        return cost;
+    }
+    
+    private static int binarySearch(int[] arr, int value) {
+        int left = 0;
+        int right = arr.length;
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (arr[mid] <= value) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+}

From 5db3be7839486bddeb3e561ee5a887bac4036476 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 19 Jun 2023 17:00:37 -0700
Subject: [PATCH 1716/2175] Updated Find the Highest Altitude.java

---
 Easy/Find the Highest Altitude.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Easy/Find the Highest Altitude.java b/Easy/Find the Highest Altitude.java
index a7df7bf1..aa7d12e5 100644
--- a/Easy/Find the Highest Altitude.java	
+++ b/Easy/Find the Highest Altitude.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public int largestAltitude(int[] gain) {
-    int highestAltitude = 0;
-    int currAltitude = 0;
-    for (int i = 0; i < gain.length; i++) {
-      currAltitude += gain[i];
-      highestAltitude = Math.max(highestAltitude, currAltitude);
+    public int largestAltitude(int[] gain) {
+        int highestAltitude = 0;
+        int currAltitude = 0;
+        for (int i = 0; i < gain.length; i++) {
+            currAltitude = currAltitude + gain[i];
+            highestAltitude = Math.max(highestAltitude, currAltitude);
+        }
+        return highestAltitude;
     }
-    return highestAltitude;
-  }
 }

From 81e70f92df9bc013c7f0edc347f338f830623323 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 19 Jun 2023 17:11:01 -0700
Subject: [PATCH 1717/2175] Added Total Distance Traveled.java

---
 Easy/Total Distance Traveled.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Total Distance Traveled.java

diff --git a/Easy/Total Distance Traveled.java b/Easy/Total Distance Traveled.java
new file mode 100644
index 00000000..e9697899
--- /dev/null
+++ b/Easy/Total Distance Traveled.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int distanceTraveled(int mainTank, int additionalTank) {
+        return (mainTank + Math.min((mainTank - 1) / 4, additionalTank)) * 10;
+    }
+}

From c9ba0096554df67e1a40f6a55aaaca2af0fabe47 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 20 Jun 2023 17:44:27 -0700
Subject: [PATCH 1718/2175] Added Minimum Cost to Make Array Equal.java

---
 Hard/Minimum Cost to Make Array Equal.java | 27 ++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Hard/Minimum Cost to Make Array Equal.java

diff --git a/Hard/Minimum Cost to Make Array Equal.java b/Hard/Minimum Cost to Make Array Equal.java
new file mode 100644
index 00000000..9fe9b8f9
--- /dev/null
+++ b/Hard/Minimum Cost to Make Array Equal.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public long minCost(int[] nums, int[] cost) {
+        int n = nums.length;
+        int[][] numWithCost = new int[n][2];
+        for (int i = 0; i < n; i++) {
+            numWithCost[i] = new int[]{nums[i], cost[i]};    
+        }
+        Arrays.sort(numWithCost, (a, b) -> a[0] - b[0]);
+        long[] prefixCost = new long[n];
+        prefixCost[0] = numWithCost[0][1];
+        for (int i = 1; i < n; i++) {
+            prefixCost[i] = numWithCost[i][1] + prefixCost[i - 1];
+        }
+        long totalCost = 0;
+        for (int i = 1; i < n; i++) {
+            totalCost += 1L * numWithCost[i][1] * (numWithCost[i][0] - numWithCost[0][0]);
+        }
+        long result = totalCost;  
+        for (int i = 1; i < n; ++i) {
+            int gap = numWithCost[i][0] - numWithCost[i - 1][0];
+            totalCost += 1L * prefixCost[i - 1] * gap;
+            totalCost -= 1L * (prefixCost[n - 1] - prefixCost[i - 1]) * gap;
+            result = Math.min(result, totalCost);
+        }
+        return result;
+    }
+}

From d9bf069395adaabd39adb6a479d537bf0e5a163d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 22 Jun 2023 07:22:19 -0700
Subject: [PATCH 1719/2175] Added Best Time to Buy and Sell Stock with
 Transaction Fee.java

---
 ... to Buy and Sell Stock with Transaction Fee.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Best Time to Buy and Sell Stock with Transaction Fee.java

diff --git a/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java b/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java
new file mode 100644
index 00000000..1251e8d0
--- /dev/null
+++ b/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int maxProfit(int[] prices, int fee) {
+        int n = prices.length;
+        int[] notHolding = new int[n];
+        int[] holding = new int[n];
+        holding[0] = -prices[0];
+        for (int i = 1; i < n; i++) {
+            holding[i] = Math.max(holding[i - 1], notHolding[i - 1] - prices[i]);
+            notHolding[i] = Math.max(notHolding[i - 1], holding[i - 1] + prices[i] - fee);
+        }
+        return notHolding[n - 1];
+    }
+}

From 157f7bfd46771922c330031f695cb639389962fb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 23 Jun 2023 06:50:39 -0700
Subject: [PATCH 1720/2175] Updated Longest Arithmetic Subsequence.java

---
 Medium/Longest Arithmetic Subsequence.java | 24 +++++++++++-----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Medium/Longest Arithmetic Subsequence.java b/Medium/Longest Arithmetic Subsequence.java
index 70544ee4..67a7fbb6 100644
--- a/Medium/Longest Arithmetic Subsequence.java	
+++ b/Medium/Longest Arithmetic Subsequence.java	
@@ -1,15 +1,15 @@
 class Solution {
-  public int longestArithSeqLength(int[] nums) {
-    int result = 2;
-    Map<Integer, Integer>[] dp = new HashMap[nums.length];
-    for (int i = 0; i < nums.length; i++) {
-      dp[i] = new HashMap<>();
-      for (int j = 0; j < i; j++) {
-        int diff = nums[i] - nums[j];
-        dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1);
-        result = Math.max(result, dp[i].get(diff));
-      }
+    public int longestArithSeqLength(int[] nums) {
+        int result = 0;
+        Map<Integer, Integer>[] dp = new HashMap[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            dp[i] = new HashMap<>();
+            for (int j = 0; j < i; j++) {
+                int diff = nums[j] - nums[i];
+                dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1);
+                result = Math.max(result, dp[i].get(diff));
+            }
+        }
+        return result;
     }
-    return result;
-  }
 }

From 9f9edb0697d85042e4e917f248699facb234ce24 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 24 Jun 2023 07:41:33 -0700
Subject: [PATCH 1721/2175] Added Tallest Billboard.java

---
 Hard/Tallest Billboard.java | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 Hard/Tallest Billboard.java

diff --git a/Hard/Tallest Billboard.java b/Hard/Tallest Billboard.java
new file mode 100644
index 00000000..04f81763
--- /dev/null
+++ b/Hard/Tallest Billboard.java	
@@ -0,0 +1,35 @@
+class Solution {
+    public int tallestBillboard(int[] rods) {
+        int n = rods.length;
+        Map<Integer, Integer> firstHalf = helper(rods, 0, n / 2);
+        Map<Integer, Integer> secondHalf = helper(rods, n / 2, n);
+        int result = 0;
+        for (Integer difference : firstHalf.keySet()) {
+            if (secondHalf.containsKey(-1 * difference)) {
+                result = Math.max(result, firstHalf.get(difference) + secondHalf.get(-1 * difference));
+            }
+        }
+        return result;
+    }
+    
+    private Map<Integer, Integer> helper(int[] rods, int leftIdx, int rightIdx) {
+        Set<Pair<Integer, Integer>> states = new HashSet<>();
+        states.add(new Pair(0, 0));
+        for (int i = leftIdx; i < rightIdx; i++) {
+            int rod = rods[i];
+            Set<Pair<Integer, Integer>> newStates = new HashSet<>();
+            for (Pair<Integer, Integer> state : states) {
+                newStates.add(new Pair(state.getKey() + rod, state.getValue()));
+                newStates.add(new Pair(state.getKey(), state.getValue() + rod));
+            }
+            states.addAll(newStates);
+        }
+        Map<Integer, Integer> dp = new HashMap<>();
+        for (Pair<Integer, Integer> pair : states) {
+            Integer left = pair.getKey();
+            Integer right = pair.getValue();
+            dp.put(left - right, Math.max(dp.getOrDefault(left - right, 0), left));
+        }
+        return dp;
+    }
+}

From b66cf22f9d15257d8df8b820c177f485bead5681 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 24 Jun 2023 14:23:21 -0700
Subject: [PATCH 1722/2175] Added Find Maximum Number of String Pairs.java

---
 Easy/Find Maximum Number of String Pairs.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Find Maximum Number of String Pairs.java

diff --git a/Easy/Find Maximum Number of String Pairs.java b/Easy/Find Maximum Number of String Pairs.java
new file mode 100644
index 00000000..f2673fbe
--- /dev/null
+++ b/Easy/Find Maximum Number of String Pairs.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int maximumNumberOfStringPairs(String[] words) {
+        Set<String> set = new HashSet<>();
+        int pairCount = 0;
+        for (String word : words) {
+            if (set.contains(new StringBuilder(word).reverse().toString())) {
+                pairCount++;
+            }
+            set.add(word);
+        }
+        return pairCount;
+    }
+}

From 0259040e6657c3e246ad602b6d9d88797cf460a0 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 25 Jun 2023 07:33:31 -0700
Subject: [PATCH 1723/2175] Added Number of Beautiful Pairs.java

---
 Easy/Number of Beautiful Pairs.java | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Easy/Number of Beautiful Pairs.java

diff --git a/Easy/Number of Beautiful Pairs.java b/Easy/Number of Beautiful Pairs.java
new file mode 100644
index 00000000..2993a81e
--- /dev/null
+++ b/Easy/Number of Beautiful Pairs.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int countBeautifulPairs(int[] nums) {
+        int pairCount = 0;
+        for (int i = 0; i < nums.length; i++) {
+            int lastDigit = nums[i] % 10;
+            for (int j = 0; j < i; j++) {
+                int firstDigit = getFirstDigit(nums[j]);
+                pairCount += gcd(firstDigit, lastDigit) == 1 ? 1 : 0;
+            }
+        }
+        return pairCount;
+    }
+    
+    private static int getFirstDigit(int num) {
+        while (num >= 10) {
+            num /= 10;
+        }
+        return num;
+    }
+    
+    private static int gcd(int a, int b) {
+        while (b != 0) {
+            int temp = a % b;
+            a = b;
+            b = temp;
+        }
+        return a;
+    }
+}

From a4d59271959434a39250148d30dbfc7aff266d5d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 26 Jun 2023 08:48:34 -0700
Subject: [PATCH 1724/2175] Added Total Cost to Hire K Workers.java

---
 Medium/Total Cost to Hire K Workers.java | 29 ++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Total Cost to Hire K Workers.java

diff --git a/Medium/Total Cost to Hire K Workers.java b/Medium/Total Cost to Hire K Workers.java
new file mode 100644
index 00000000..c5708a4b
--- /dev/null
+++ b/Medium/Total Cost to Hire K Workers.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public long totalCost(int[] costs, int k, int candidates) {
+        PriorityQueue<Integer> headWorkers = new PriorityQueue<>();
+        PriorityQueue<Integer> tailWorkers = new PriorityQueue<>();
+        for (int i = 0; i < candidates; i++) {
+            headWorkers.add(costs[i]);
+        }
+        for (int i = Math.max(candidates, costs.length - candidates); i < costs.length; i++) {
+            tailWorkers.add(costs[i]);
+        }
+        int headIdx = candidates;
+        int tailIdx = costs.length - candidates - 1;
+        long result = 0;
+        for (int i = 0; i < k; i++) {
+            if (tailWorkers.isEmpty() || (!headWorkers.isEmpty() && headWorkers.peek() <= tailWorkers.peek())) {
+                result += headWorkers.poll();
+                if (headIdx <= tailIdx) {
+                    headWorkers.add(costs[headIdx++]);
+                }
+            } else {
+                result += tailWorkers.poll();
+                if (headIdx <= tailIdx) {
+                    tailWorkers.add(costs[tailIdx--]);
+                }
+            }
+        }
+        return result;
+    }
+}

From dfa8b889cc78825fb08b7c7ce5c6216c3feb6daf Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 26 Jun 2023 17:37:51 -0700
Subject: [PATCH 1725/2175] Updated Find K Pairs with Smallest Sums.java

---
 Medium/Find K Pairs with Smallest Sums.java | 70 +++++++--------------
 1 file changed, 21 insertions(+), 49 deletions(-)

diff --git a/Medium/Find K Pairs with Smallest Sums.java b/Medium/Find K Pairs with Smallest Sums.java
index 894ca10d..f29f5c15 100644
--- a/Medium/Find K Pairs with Smallest Sums.java	
+++ b/Medium/Find K Pairs with Smallest Sums.java	
@@ -1,54 +1,26 @@
-class Solution {
-    public List<int[]> kSmallestPairs(int[] nums1, int[] nums2, int k) {
-        List<int[]> ans = new ArrayList<>();
-
-        if (nums1.length == 0 || nums2.length == 0 || k == 0) {
-            return ans;
-        }
-
-        PriorityQueue<Element> pq = new PriorityQueue<>(new Comparator<Element>() {
-            @Override
-            public int compare(Element o1, Element o2) {
-                return (o1.x + o1.y) - (o2.x + o2.y);
-            }
-        });
-
-        for (int i=0; i<nums2.length && i < k; i++) {
-            pq.offer(new Element(0, nums2[i], nums1[0]));
-        }
-
+class Solution {
+    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
+        List<List<Integer>> result = new ArrayList<>();
+        Set<Pair<Integer, Integer>> visited = new HashSet<>();
+        pq.add(new int[]{0, 0, nums1[0] + nums2[0]});
+        visited.add(new Pair<Integer, Integer>(0, 0));
         while (k-- > 0 && !pq.isEmpty()) {
-            Element temp = pq.poll();
-            ans.add(new int[]{temp.y, temp.x});
-
-            if (temp.idx >= nums1.length-1) {
-                continue;
+            int[] removed = pq.poll();
+            int i = removed[0];
+            int j = removed[1];
+            result.add(List.of(nums1[i], nums2[j]));
+            Pair<Integer, Integer> nums1Pair = new Pair<Integer, Integer>(i + 1, j);
+            Pair<Integer, Integer> nums2Pair = new Pair<Integer, Integer>(i, j + 1);
+            if (i + 1 < nums1.length && !visited.contains(nums1Pair)) {
+                pq.add(new int[]{i + 1, j, nums1[i + 1] + nums2[j]});
+                visited.add(nums1Pair);
+            }
+            if (j + 1 < nums2.length && !visited.contains(nums2Pair)) {
+                pq.add(new int[]{i, j + 1, nums1[i] + nums2[j + 1]});
+                visited.add(nums2Pair);
             }
-
-            pq.offer(new Element(temp.idx+1, temp.x, nums1[temp.idx+1]));
-        }
-
-        return ans;
-    }
-
-    class Element {
-        int idx;
-        int x;
-        int y;
-
-        public Element(int val, int x, int y) {
-            this.idx = val;
-            this.x = x;
-            this.y = y;
-        }
-
-        @Override
-        public String toString() {
-            return "Element{" +
-                    "idx=" + idx +
-                    ", x=" + x +
-                    ", y=" + y +
-                    '}';
         }
+        return result;
     }
 }

From 52111fe5405a6b1d1842b5ec063301e9dbd499a1 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 1 Jul 2023 22:03:18 -0700
Subject: [PATCH 1726/2175] Added Longest Even Odd Subarray With Threshold.java

---
 ...gest Even Odd Subarray With Threshold.java | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Easy/Longest Even Odd Subarray With Threshold.java

diff --git a/Easy/Longest Even Odd Subarray With Threshold.java b/Easy/Longest Even Odd Subarray With Threshold.java
new file mode 100644
index 00000000..f3dcc239
--- /dev/null
+++ b/Easy/Longest Even Odd Subarray With Threshold.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int longestAlternatingSubarray(int[] nums, int threshold) {
+        int maxLength = 0;
+        int start = 0;
+        boolean evenRequired = true;
+        int idx = 0;
+        while (idx < nums.length) {
+            if (nums[idx] > threshold) {
+                idx++;
+                start = idx;
+                evenRequired = true;
+                continue;
+            }
+            if (nums[idx] % 2 == 0 && !evenRequired) {
+                start = idx;
+                evenRequired = true;
+                continue;
+            }
+            if (nums[idx] % 2 != 0 && evenRequired) {
+                idx++;
+                start = idx;
+                evenRequired = true;
+                continue;
+            }
+            idx++;
+            maxLength = Math.max(maxLength, idx - start);
+            evenRequired = !evenRequired;
+        }
+        return maxLength;
+    }
+}

From ab79856e35201bbb7e6b3d0d09808557f0d597d7 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 2 Jul 2023 17:24:13 -0700
Subject: [PATCH 1727/2175] Updated Buddy Strings.java

---
 Easy/Buddy Strings.java | 35 +++++++++++++++++------------------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git a/Easy/Buddy Strings.java b/Easy/Buddy Strings.java
index 83f94a5a..f34ecf35 100644
--- a/Easy/Buddy Strings.java	
+++ b/Easy/Buddy Strings.java	
@@ -1,33 +1,32 @@
 class Solution {
+    
+    private static final int SWAP_DONE_IDX = Integer.MIN_VALUE;
+    
     public boolean buddyStrings(String s, String goal) {
         if (s.length() != goal.length()) {
             return false;
         }
-        int mismatchIdx = -1;
+        int swapIdx = -1;
         Set<Character> set = new HashSet<>();
         for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == goal.charAt(i)) {
+                set.add(s.charAt(i));
+                continue;
+            }
             if (s.charAt(i) != goal.charAt(i)) {
-                if (mismatchIdx == Integer.MAX_VALUE) {
+                if (swapIdx == SWAP_DONE_IDX) {
                     return false;
                 }
-                if (mismatchIdx == -1) {
-                    mismatchIdx = i;
-                } else {
-                    if (!(s.charAt(mismatchIdx) == goal.charAt(i) && s.charAt(i) == goal.charAt(mismatchIdx))) {
-                        return false;
-                    }
-                    mismatchIdx = Integer.MAX_VALUE;
+                if (swapIdx == -1) {
+                    swapIdx = i;
+                    continue;
+                } 
+                if (!(s.charAt(swapIdx) == goal.charAt(i) && s.charAt(i) == goal.charAt(swapIdx))) {
+                    return false;
                 }
-            } else {
-                set.add(s.charAt(i));
+                swapIdx = SWAP_DONE_IDX;
             }
         }
-        if (mismatchIdx != -1 && mismatchIdx != Integer.MAX_VALUE) {
-            return false;
-        }
-        if (mismatchIdx == -1) {
-            return s.length() > set.size();
-        }
-        return true;
+        return (swapIdx != -1 && swapIdx == SWAP_DONE_IDX) || (swapIdx == -1 && set.size() < s.length());
     }
 }

From 85c734aa61a38757ae91ed354a9262d329d0448e Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 4 Jul 2023 17:44:18 -0700
Subject: [PATCH 1728/2175] Added Longest Subarray of 1's After Deleting One
 Element.java

---
 ...ubarray of 1's After Deleting One Element.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Longest Subarray of 1's After Deleting One Element.java

diff --git a/Medium/Longest Subarray of 1's After Deleting One Element.java b/Medium/Longest Subarray of 1's After Deleting One Element.java
new file mode 100644
index 00000000..b10a1675
--- /dev/null
+++ b/Medium/Longest Subarray of 1's After Deleting One Element.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int zeroIdx = -1;
+        int windowSize = 0;
+        int startIdx = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == 0) {
+                startIdx = zeroIdx + 1;
+                zeroIdx = i;
+            }
+            windowSize = Math.max(windowSize, i - startIdx);
+        }
+        return windowSize;
+    }
+}

From 97c634930a2062e9a1d5d42b7dc3b6b3ea16a1de Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 6 Jul 2023 17:24:24 -0700
Subject: [PATCH 1729/2175] Added Maximize the Confusion of an Exam.java

---
 Medium/Maximize the Confusion of an Exam.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Maximize the Confusion of an Exam.java

diff --git a/Medium/Maximize the Confusion of an Exam.java b/Medium/Maximize the Confusion of an Exam.java
new file mode 100644
index 00000000..3e7e14d1
--- /dev/null
+++ b/Medium/Maximize the Confusion of an Exam.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxConsecutiveAnswers(String answerKey, int k) {
+        int resultSize = k;
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < k; i++) {
+            map.put(answerKey.charAt(i), map.getOrDefault(answerKey.charAt(i), 0) + 1);
+        }
+        int start = 0;
+        for (int i = k; i < answerKey.length(); i++) {
+            map.put(answerKey.charAt(i), map.getOrDefault(answerKey.charAt(i), 0) + 1);
+            while (Math.min(map.getOrDefault('T', 0), map.getOrDefault('F', 0)) > k) {
+                map.put(answerKey.charAt(start), map.get(answerKey.charAt(start)) - 1);
+                start++;
+            }
+            resultSize = Math.max(resultSize, i - start + 1);
+        }
+        return resultSize;
+    }
+}

From 5c15c2c4ec60e4e30a7528e61cd89c720d3a0f1c Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 8 Jul 2023 10:58:57 -0700
Subject: [PATCH 1730/2175] Added Longest Alternating Subarray.java

---
 Easy/Longest Alternating Subarray.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Longest Alternating Subarray.java

diff --git a/Easy/Longest Alternating Subarray.java b/Easy/Longest Alternating Subarray.java
new file mode 100644
index 00000000..65de425c
--- /dev/null
+++ b/Easy/Longest Alternating Subarray.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int alternatingSubarray(int[] nums) {
+        int start = 0;
+        int maxLength = -1;
+        int expectedDiff = 1;
+        for (int i = 1; i < nums.length;) {
+            if (nums[i] - nums[i - 1] != expectedDiff) {
+                if (nums[i] - nums[i - 1] != 1) {
+                    i++;
+                } 
+                start = i - 1;
+                expectedDiff = 1;
+                continue;
+            }
+            expectedDiff *= -1;
+            maxLength = Math.max(maxLength, i - start + 1);
+            i++;
+        }
+        return maxLength;
+    }
+}

From ca0aa5f3d50a52363b2ed46cffb0d1981dc0c16d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 9 Jul 2023 06:43:54 -0700
Subject: [PATCH 1731/2175] Added Find the Maximum Achievable Number.java

---
 Easy/Find the Maximum Achievable Number.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Find the Maximum Achievable Number.java

diff --git a/Easy/Find the Maximum Achievable Number.java b/Easy/Find the Maximum Achievable Number.java
new file mode 100644
index 00000000..841862be
--- /dev/null
+++ b/Easy/Find the Maximum Achievable Number.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int theMaximumAchievableX(int num, int t) {
+        return num + 2 * t;
+    }
+}

From 6cb7d533c288ce708d1e8d210a97ed3a63b5ff43 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 9 Jul 2023 06:51:46 -0700
Subject: [PATCH 1732/2175] Updated Longest Substring with At Most K Distinct
 Characters.java

---
 ...ng with At Most K Distinct Characters.java | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/Medium/Longest Substring with At Most K Distinct Characters.java b/Medium/Longest Substring with At Most K Distinct Characters.java
index 02936a53..a793b8c0 100644
--- a/Medium/Longest Substring with At Most K Distinct Characters.java	
+++ b/Medium/Longest Substring with At Most K Distinct Characters.java	
@@ -1,21 +1,21 @@
 class Solution {
-  public int lengthOfLongestSubstringKDistinct(String s, int k) {
-    Map<Character, Integer> map = new HashMap<>();
-    int startIdx = 0;
-    int endIdx = 0;
-    int maxLength = 0;
-    while (endIdx < s.length()) {
-      map.put(s.charAt(endIdx), map.getOrDefault(s.charAt(endIdx), 0) + 1);
-      endIdx++;
-      while (startIdx < endIdx && map.size() > k) {
-        map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0 ) - 1);
-        if (map.get(s.charAt(startIdx))  == 0) {
-          map.remove(s.charAt(startIdx));
+    public int lengthOfLongestSubstringKDistinct(String s, int k) {
+        Map<Character, Integer> map = new HashMap<>();
+        int start = 0;
+        int end = 0;
+        int maxLength = 0;
+        while (end < s.length()) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            while (start <= end && map.size() > k) {
+                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
+                if (map.get(s.charAt(start)) == 0) {
+                    map.remove(s.charAt(start));
+                }
+                start++;
+            }
+            end++;
+            maxLength = Math.max(maxLength, end - start);
         }
-        startIdx++;
-      }
-      maxLength = Math.max(maxLength, endIdx - startIdx);
+        return maxLength;
     }
-    return maxLength;
-  }
 }

From f38831aadfe1c0ce6e3ab6c4aa88f958db2e2cad Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 9 Jul 2023 18:46:15 -0700
Subject: [PATCH 1733/2175] Updated Minimum Depth of a Binary Tree.java

---
 Easy/Minimum Depth of a Binary Tree.java | 46 ++++++++++++------------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/Easy/Minimum Depth of a Binary Tree.java b/Easy/Minimum Depth of a Binary Tree.java
index e1d21cc6..0da04114 100644
--- a/Easy/Minimum Depth of a Binary Tree.java	
+++ b/Easy/Minimum Depth of a Binary Tree.java	
@@ -14,31 +14,29 @@
  * }
  */
 class Solution {
-  public int minDepth(TreeNode root) {
-    if (root == null) {
-      return 0;
-    }
-    int steps = 1;
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      // Level iteration
-      while (size-- > 0) {
-        TreeNode removed = queue.remove();
-        // Leaf reached
-        if (removed.left == null && removed.right == null) {
-          return steps;
-        }
-        if (removed.left != null) {
-          queue.add(removed.left);
+    public int minDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
         }
-        if (removed.right != null) {
-          queue.add(removed.right);
+        int level = 1;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                if (removed.left == null && removed.right == null) {
+                    return level;
+                }
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            level++;
         }
-      }
-      steps++;
+        return level;
     }
-    return steps;
-  }
 }

From b86b4488f7a3d51036e42fabc46dd9223930651d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 11 Jul 2023 08:21:15 -0700
Subject: [PATCH 1734/2175] Updated All Nodes Distance K in Binary Tree.java

---
 .../All Nodes Distance K in Binary Tree.java  | 77 +++++++++----------
 1 file changed, 38 insertions(+), 39 deletions(-)

diff --git a/Medium/All Nodes Distance K in Binary Tree.java b/Medium/All Nodes Distance K in Binary Tree.java
index 13e9485b..9f88451e 100644
--- a/Medium/All Nodes Distance K in Binary Tree.java	
+++ b/Medium/All Nodes Distance K in Binary Tree.java	
@@ -8,49 +8,48 @@
  * }
  */
 class Solution {
-  public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
-    List<Integer> result = new ArrayList<>();
-    dfs(root, target, k, result);
-    return new ArrayList<>(result);
-  }
-  
-  private int dfs(TreeNode node, TreeNode target, int k, List<Integer> result) {
-    if (node == null) {
-      return -1;
+    public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
+        List<Integer> result = new ArrayList<>();
+        dfs(root, target, k, result);
+        return result;
     }
-    if (node == target) {
-      addToResult(node, 0, result, k);
-      return 1;
-    } else {
-      int left = dfs(node.left, target, k, result);
-      int right = dfs(node.right, target, k, result);
-      if (left != -1) {
-        if (left == k) {
-          result.add(node.val);
+    
+    private int dfs(TreeNode node, TreeNode target, int k, List<Integer> result) {
+        if (node == null) {
+            return -1;
         }
-        addToResult(node.right, left + 1, result, k);
-        return left + 1;
-      } else if (right != -1) {
-        if (right == k) {
-          result.add(node.val);
+        if (node == target) {
+            dfs(node, 0, k, result);
+            return 1;
+        }
+        int left = dfs(node.left, target, k, result);
+        if (left != -1) {
+            if (left == k) {
+               result.add(node.val);
+            }
+            dfs(node.right, left + 1, k, result);
+            return left + 1;
+        }
+        int right = dfs(node.right, target, k, result);
+        if (right != -1) {
+            if (right == k) {
+               result.add(node.val);
+            }
+            dfs(node.left, right + 1, k, result);
+            return right + 1;
         }
-        addToResult(node.left, right + 1, result, k);
-        return right + 1;
-      } else {
         return -1;
-      }
-    }
-  }
-  
-  private void addToResult(TreeNode node, int dist, List<Integer> result, int k) {
-    if (node == null || dist > k) {
-      return;
     }
-    if (dist == k) {
-      result.add(node.val);
-    } else {
-      addToResult(node.left, dist + 1, result, k);
-      addToResult(node.right, dist + 1, result, k);
+    
+    private void dfs(TreeNode node, int distance, int k, List<Integer> result) {
+        if (node == null || distance > k) {
+            return;
+        }
+        if (distance == k) {
+            result.add(node.val);
+            return;
+        }
+        dfs(node.left, distance + 1, k, result);
+        dfs(node.right, distance + 1, k, result);
     }
-  }
 }

From 8e7e64da784242b3c62ddb04fabf5da83baae74a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 11 Jul 2023 18:30:11 -0700
Subject: [PATCH 1735/2175] Added Find Eventual Safe States.java

---
 Medium/Find Eventual Safe States.java | 35 +++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 Medium/Find Eventual Safe States.java

diff --git a/Medium/Find Eventual Safe States.java b/Medium/Find Eventual Safe States.java
new file mode 100644
index 00000000..2948587d
--- /dev/null
+++ b/Medium/Find Eventual Safe States.java	
@@ -0,0 +1,35 @@
+class Solution {
+    public List<Integer> eventualSafeNodes(int[][] graph) {
+        int n = graph.length;
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        int[] indegree = new int[n];
+        for (int i = 0; i < n; i++) {
+            for (Integer conn : graph[i]) {
+                indegree[i]++;
+                map.computeIfAbsent(conn, k -> new HashSet<>()).add(i);
+            }
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i = 0; i < n; i++) {    
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+        List<Integer> result = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                result.add(removed);
+                for (Integer conn : map.getOrDefault(removed, new HashSet<>())) {
+                    indegree[conn]--;
+                    if (indegree[conn] == 0) {
+                        queue.add(conn);
+                    }
+                }
+            }
+        }
+        Collections.sort(result);
+        return result;
+    }
+}

From 3523744aed753badf83a54e68879ab20ed5655ad Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Thu, 13 Jul 2023 09:08:53 -0700
Subject: [PATCH 1736/2175] Updated Course Schedule.java

---
 Medium/Course Schedule.java | 52 +++++++++++++++++++------------------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/Medium/Course Schedule.java b/Medium/Course Schedule.java
index bea1a964..1f8c0693 100644
--- a/Medium/Course Schedule.java	
+++ b/Medium/Course Schedule.java	
@@ -1,29 +1,31 @@
 class Solution {
-  public boolean canFinish(int numCourses, int[][] prerequisites) {
-    Map<Integer, Set<Integer>> map = new HashMap<>();
-    int[] indegree = new int[numCourses];
-    for (int[] prerequisite : prerequisites) {
-      map.computeIfAbsent(prerequisite[1], k -> new HashSet<>()).add(prerequisite[0]);
-      indegree[prerequisite[0]]++;
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    Set<Integer> taken = new HashSet<>();
-    for (int i = 0; i < numCourses; i++) {
-      if (indegree[i] == 0) {
-        queue.add(i);
-        taken.add(i);
-      }
-    }
-    while (!queue.isEmpty()) {
-      int removed = queue.remove();
-      for (Integer dependentCourse : map.getOrDefault(removed, new HashSet<>())) {
-        indegree[dependentCourse]--;
-        if (indegree[dependentCourse] == 0) {
-          taken.add(dependentCourse);
-          queue.add(dependentCourse);
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        int[] indegree = new int[numCourses];
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        for (int[] prerequisite : prerequisites) {
+            int course = prerequisite[0];
+            int prereq = prerequisite[1];
+            indegree[course]++;
+            map.computeIfAbsent(prereq, k -> new HashSet<>()).add(course);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        Set<Integer> visited = new HashSet<>();
+        for (int i = 0; i < numCourses; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+                visited.add(i);
+            }            
+        }
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer conn : map.getOrDefault(removed, new HashSet<>())) {
+                indegree[conn]--;
+                if (indegree[conn] == 0) {
+                    queue.add(conn);
+                    visited.add(conn);
+                }
+            }
         }
-      }
+        return visited.size() == numCourses;
     }
-    return taken.size() == numCourses;
-  }
 }

From a89344a94b320af42b8c740e388d89db9e53db7f Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 14 Jul 2023 07:43:29 -0700
Subject: [PATCH 1737/2175] Added Longest Arithmetic Subsequence of Given
 Difference.java

---
 ...t Arithmetic Subsequence of Given Difference.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Longest Arithmetic Subsequence of Given Difference.java

diff --git a/Medium/Longest Arithmetic Subsequence of Given Difference.java b/Medium/Longest Arithmetic Subsequence of Given Difference.java
new file mode 100644
index 00000000..ef48493e
--- /dev/null
+++ b/Medium/Longest Arithmetic Subsequence of Given Difference.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public int longestSubsequence(int[] arr, int difference) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int maxValue = 0;
+        for (int num : arr) {
+            int endingSubLength = map.getOrDefault(num - difference, 0);
+            map.put(num, endingSubLength + 1);
+            maxValue = Math.max(maxValue, map.get(num));
+        }
+        return maxValue;
+    }
+}

From 91dd115b39eb3e77b54c889f0688c6e93b99a48a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Fri, 14 Jul 2023 13:11:54 -0700
Subject: [PATCH 1738/2175] Added Web Crawler Multithreaded.java

---
 Concurrency/Web Crawler Multithreaded.java | 108 +++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 Concurrency/Web Crawler Multithreaded.java

diff --git a/Concurrency/Web Crawler Multithreaded.java b/Concurrency/Web Crawler Multithreaded.java
new file mode 100644
index 00000000..bb48616c
--- /dev/null
+++ b/Concurrency/Web Crawler Multithreaded.java	
@@ -0,0 +1,108 @@
+/**
+ * // This is the HtmlParser's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface HtmlParser {
+ *     public List<String> getUrls(String url) {}
+ * }
+ */
+import java.net.URI;
+import java.net.URISyntaxException;
+
+
+class Solution {
+    public List<String> crawl(String startUrl, HtmlParser htmlParser) {
+        ResultRecord resultRecord = new ResultRecord();
+        CrawlTask task = new CrawlTask(
+            startUrl, htmlParser, resultRecord, UrlUtil.parseHostname(startUrl));
+        try {
+            task.start();
+            task.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        return resultRecord.getResultList();
+    }
+}
+
+class CrawlTask extends Thread {
+    
+    private final String url;
+    private final HtmlParser htmlParser;
+    private final ResultRecord resultRecord;
+    private final String parentHost;
+    
+    public CrawlTask(String url, 
+                     HtmlParser htmlParser, 
+                     ResultRecord resultRecord,
+                     String parentHost) {
+        this.url = url;
+        this.htmlParser = htmlParser;
+        this.resultRecord = resultRecord;
+        this.parentHost = parentHost;
+    }
+    
+    public void run() {
+        String hostname = UrlUtil.parseHostname(url);
+        if (!hostname.equals(parentHost)) {
+            return;
+        }
+        if (resultRecord.addIfNotExists(url)) {
+            List<String> childUrls = htmlParser.getUrls(url);
+            List<CrawlTask> tasks = new ArrayList<>();
+            for (String childUrl : childUrls) {
+                tasks.add(new CrawlTask(
+                    childUrl, htmlParser, resultRecord, parentHost));
+            }
+            try {
+                for (CrawlTask task : tasks) {
+                    task.start();
+                }
+                for (CrawlTask task : tasks) {
+                    task.join();
+                }
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+
+class UrlUtil {
+    
+    public static String parseHostname(String url) {
+        try {
+            URI uri = new URI(url);
+            return uri.getHost();
+        } catch(URISyntaxException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}
+
+class ResultRecord {
+
+    private Set<String> urls;
+    private Semaphore mutex;
+    
+    public ResultRecord() {
+        this.urls = new HashSet<>();
+        this.mutex = new Semaphore(1);
+    }
+    
+    public boolean addIfNotExists(String url) {
+        try {
+            this.mutex.acquire();
+            boolean added = this.urls.add(url);
+            this.mutex.release();
+            return added;
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        return false;
+    } 
+    
+    public List<String> getResultList() {
+        return new ArrayList<>(urls);
+    }
+}

From 32088448fd2cb7b6171d8fff65087b68a7aea181 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 15 Jul 2023 14:18:10 -0700
Subject: [PATCH 1739/2175] Updated Combination Sum.java

---
 Medium/Combination Sum.java | 35 ++++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/Medium/Combination Sum.java b/Medium/Combination Sum.java
index de3b3740..6d9e8f77 100644
--- a/Medium/Combination Sum.java	
+++ b/Medium/Combination Sum.java	
@@ -1,21 +1,22 @@
 class Solution {
-  public List<List<Integer>> combinationSum(int[] candidates, int target) {
-    List<List<Integer>> result = new ArrayList<>();
-    helper(candidates, 0, target, new ArrayList<>(), result);
-    return result;
-  }
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList<>();
+        helper(candidates, target, new ArrayList<>(), result, 0);
+        return result;
+    }
 
-  private void helper(int[] candidates, int idx, int target, List<Integer> currCombination,
-      List<List<Integer>> result) {
-    if (target == 0) {
-      result.add(new ArrayList<>(currCombination));
-    } 
-    if (target > 0 && idx < candidates.length) {
-      for (int i = idx; i < candidates.length; i++) {
-        currCombination.add(candidates[i]);
-        helper(candidates, i, target - candidates[i], currCombination, result);
-        currCombination.remove(currCombination.size() - 1);
-      }
+    private void helper(int[] candidates, int target, List<Integer> combination, List<List<Integer>> result, int idx) {
+        if (target < 0 || idx == candidates.length) {
+            return;
+        }
+        if (target == 0) {
+            result.add(combination);
+            return;
+        }
+        for (int i = idx; i < candidates.length; i++) {
+            combination.add(candidates[i]);
+            helper(candidates, target - candidates[i], new ArrayList<>(combination), result, i);
+            combination.remove(combination.size() - 1);
+        }
     }
-  }
 }

From 343b1fc60b051544444d75ac0ced78454c36004d Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 15 Jul 2023 14:43:55 -0700
Subject: [PATCH 1740/2175] Updated Reorganize String.java

---
 Medium/Reorganize String.java | 63 ++++++++++++++++++-----------------
 1 file changed, 32 insertions(+), 31 deletions(-)

diff --git a/Medium/Reorganize String.java b/Medium/Reorganize String.java
index f3c2dfc1..9dd20760 100644
--- a/Medium/Reorganize String.java	
+++ b/Medium/Reorganize String.java	
@@ -1,37 +1,38 @@
 class Solution {
-  public String reorganizeString(String s) {
-    Map<Character, Integer> map = new HashMap<>();
-    for (char c : s.toCharArray()) {
-      map.put(c, map.getOrDefault(c, 0) + 1);
-    }
-    PriorityQueue<Character> pq = new PriorityQueue<>(
-        (o1, o2) -> map.get(o2).compareTo(map.get(o1)));
-    pq.addAll(map.keySet());
-    StringBuilder sb = new StringBuilder();
-    while (!pq.isEmpty()) {
-      char removed = pq.poll();
-      if (!sb.isEmpty() && sb.charAt(sb.length() - 1) == removed) {
-        if (pq.isEmpty()) {
-          return "";
+    public String reorganizeString(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int maxFrequency = 0;
+        char maxFrequencyLetter = ' ';
+        int n = s.length();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+            if (maxFrequency < map.get(c)) {
+                maxFrequency = map.get(c);
+                maxFrequencyLetter = c;
+            }
+        }
+        if (maxFrequency > (n + 1) / 2) {
+            return "";
         }
-        char secondRemoved = pq.poll();
-        pq.add(removed);
-        sb.append(secondRemoved);
-        updateStructure(map, pq, secondRemoved);
-      } else {
-        sb.append(removed);
-        updateStructure(map, pq, removed);
-      }
+        char[] letters = new char[s.length()];
+        int idx = 0;
+        idx = insertLetter(n, map, maxFrequencyLetter, letters, idx);
+        map.remove(maxFrequencyLetter);
+        for (Character key : map.keySet()) {
+            idx = insertLetter(n, map, key, letters, idx);
+        }
+        return String.valueOf(letters);
     }
-    return sb.toString();
-  }
 
-  private void updateStructure(Map<Character, Integer> map, PriorityQueue<Character> pq, char c) {
-    map.put(c, map.get(c) - 1);
-    if (map.get(c) > 0) {
-      pq.add(c);
-    } else {
-      map.remove(c);
+    private static int insertLetter(int n, Map<Character, Integer> map, char maxFrequencyLetter, char[] letters, int idx) {
+        while (map.get(maxFrequencyLetter) > 0) {
+            if (idx >= n) {
+                idx = 1;
+            }
+            letters[idx] = maxFrequencyLetter;
+            idx += 2;
+            map.put(maxFrequencyLetter, map.get(maxFrequencyLetter) - 1);
+        }
+        return idx;
     }
-  }
 }

From 2a5879f2d2341289d6088796ba1d0ad8129774c2 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 16 Jul 2023 06:45:14 -0700
Subject: [PATCH 1741/2175] Added Sum of Squares of Special Elements.java

---
 Easy/Sum of Squares of Special Elements.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Sum of Squares of Special Elements.java

diff --git a/Easy/Sum of Squares of Special Elements.java b/Easy/Sum of Squares of Special Elements.java
new file mode 100644
index 00000000..2072eee5
--- /dev/null
+++ b/Easy/Sum of Squares of Special Elements.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int sumOfSquares(int[] nums) {
+        return IntStream.range(0, nums.length)
+                .filter(i -> nums.length % (i + 1) == 0)
+                .map(i -> nums[i] * nums[i])
+                .sum();
+    }
+}

From 433c62a177ec3f9403028295aa32399eac6cb811 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 16 Jul 2023 09:07:18 -0700
Subject: [PATCH 1742/2175] Updated Lowest Common Ancestor of a Binary
 Tree.java

---
 ...west Common Ancestor of a Binary Tree.java | 26 ++++++++++++-------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/Medium/Lowest Common Ancestor of a Binary Tree.java b/Medium/Lowest Common Ancestor of a Binary Tree.java
index b49de19a..890c71e6 100644
--- a/Medium/Lowest Common Ancestor of a Binary Tree.java	
+++ b/Medium/Lowest Common Ancestor of a Binary Tree.java	
@@ -8,15 +8,21 @@
  * }
  */
 class Solution {
-  public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null || root == p || root == q) {
-      return root;
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null) {
+            return null;
+        }
+        if (root == p || root == q) {
+            return root;
+        }
+        TreeNode left = lowestCommonAncestor(root.left, p, q);
+        TreeNode right = lowestCommonAncestor(root.right, p, q);
+        if (left != null && right != null) {
+            return root;
+        }
+        if (left != null || right != null) {
+            return left != null ? left : right;
+        }
+        return null;
     }
-    TreeNode leftRoot = lowestCommonAncestor(root.left, p, q);
-    TreeNode rightRoot = lowestCommonAncestor(root.right, p, q);
-    if (leftRoot != null && rightRoot != null) {
-      return root;
-    }
-    return leftRoot != null ? leftRoot : rightRoot;
-  }
 }

From b0b2dba5fab86f28fdc192673b44d2ccf0ccbe6a Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 16 Jul 2023 09:18:31 -0700
Subject: [PATCH 1743/2175] Added Lowest Common Ancestor of a Binary Tree
 II.java

---
 ...t Common Ancestor of a Binary Tree II.java | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 Medium/Lowest Common Ancestor of a Binary Tree II.java

diff --git a/Medium/Lowest Common Ancestor of a Binary Tree II.java b/Medium/Lowest Common Ancestor of a Binary Tree II.java
new file mode 100644
index 00000000..be4c28d2
--- /dev/null
+++ b/Medium/Lowest Common Ancestor of a Binary Tree II.java	
@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        TreeNode result = lca(root, p, q);
+        if (result == p) {
+            return checkIfNodeExist(p, q) ? p : null;
+        }
+        if (result == q) {
+            return checkIfNodeExist(q, p) ? q : null;
+        }
+        return result;
+    }
+    
+    private boolean checkIfNodeExist(TreeNode root, TreeNode target) {
+        if (root == target) {
+            return true;
+        }
+        if (root == null) {
+            return false;
+        }
+        return checkIfNodeExist(root.left, target) || checkIfNodeExist(root.right, target);
+    }
+    
+    private TreeNode lca(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null) {
+            return root;
+        }
+        if (root == p || root == q) {
+            return root;
+        }
+        TreeNode left = lca(root.left, p, q);
+        TreeNode right = lca(root.right, p, q);
+        if (left != null && right != null) {
+            return root;
+        }
+        return left != null ? left : right;
+    }
+}

From bed63498e394f69d47e6d733ab530b57db7030f8 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 16 Jul 2023 17:44:51 -0700
Subject: [PATCH 1744/2175] Updated Add Two Numbers II.java

---
 Medium/Add Two Numbers II.java | 68 +++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 34 deletions(-)

diff --git a/Medium/Add Two Numbers II.java b/Medium/Add Two Numbers II.java
index fe08935f..59d717cb 100644
--- a/Medium/Add Two Numbers II.java	
+++ b/Medium/Add Two Numbers II.java	
@@ -9,40 +9,40 @@
  * }
  */
 class Solution {
-  public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-    ListNode revL1 = reverse(l1);
-    ListNode revL2 = reverse(l2);
-    ListNode dummy = new ListNode(0);
-    ListNode curr = dummy;
-    int carry = 0;
-    while (revL1 != null || revL2 != null || carry != 0) {
-      if (revL1 != null && revL2 != null) {
-        carry += revL1.val + revL2.val;
-        revL1 = revL1.next;
-        revL2 = revL2.next;
-      } else if (revL1 != null && revL2 == null) {
-        carry += revL1.val;
-        revL1 = revL1.next;
-      } else if (revL1 == null && revL2 != null) {
-        carry += revL2.val;
-        revL2 = revL2.next;
-      }
-      curr.next = new ListNode(carry % 10);
-      carry /= 10;
-      curr = curr.next;
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode rev1 = reverse(l1);
+        ListNode rev2 = reverse(l2);
+        ListNode dummy = new ListNode();
+        ListNode curr = dummy;
+        int carry = 0;
+        while (rev1 != null || rev2 != null || carry > 0) {
+            if (rev1 != null && rev2 != null) {
+                carry += rev1.val + rev2.val;
+                rev1 = rev1.next;
+                rev2 = rev2.next;
+            } else if (rev1 == null && rev2 != null) {
+                carry += rev2.val;
+                rev2 = rev2.next;
+            } else if (rev1 != null && rev2 == null) {
+                carry += rev1.val;
+                rev1 = rev1.next;
+            }
+            curr.next = new ListNode(carry % 10);
+            curr = curr.next;
+            carry /= 10;
+        }
+        return reverse(dummy.next);
     }
-    return reverse(dummy.next);
-  }
-  
-  private ListNode reverse(ListNode root) {
-    ListNode curr = root;
-    ListNode prev = null;
-    while (curr != null) {
-      ListNode next = curr.next;
-      curr.next = prev;
-      prev = curr;
-      curr = next;
+    
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
     }
-    return prev;
-  }
 }

From 86f10a6e61d9127420318e80ce5ba0a15bb64a74 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Tue, 18 Jul 2023 08:55:44 -0700
Subject: [PATCH 1745/2175] Updated LRU Cache.java

---
 Medium/LRU Cache.java | 131 +++++++++++++++++++++++-------------------
 1 file changed, 73 insertions(+), 58 deletions(-)

diff --git a/Medium/LRU Cache.java b/Medium/LRU Cache.java
index e141637f..1e1b3ae6 100644
--- a/Medium/LRU Cache.java	
+++ b/Medium/LRU Cache.java	
@@ -1,69 +1,84 @@
 class LRUCache {
+    
+    private final Map<Integer, Node> map;
+    private final int capacity;
+    private final Node head;
+    private final Node tail;
+    
+    public LRUCache(int capacity) {
+        this.capacity = capacity;
+        this.map = new HashMap<>();
+        this.head = new Node(-1, -1);
+        this.tail = new Node(-1, -1);
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+
+    public int get(int key) {
+        if (!map.containsKey(key)) {
+            return -1;
+        }
+        Node node = map.get(key);
+        removeNode(node);
+        addToFront(node);
+        return node.value;
+    }
 
-  private final Map<Integer, Node> map;
-  private final Node head;
-  private final Node tail;
-  private int capacity;
+    public void put(int key, int value) {
+        if (map.containsKey(key)) {
+            updateExistingKey(key, value);
+            return;
+        }
+        if (map.size() == this.capacity) {
+            Node leastUsed = tail.prev;
+            removeNode(leastUsed);
+            map.remove(leastUsed.key);
+        }
+        Node newNode = new Node(key, value);
+        addToFront(newNode);
+        map.put(key, newNode);
+    }
 
-  public LRUCache(int capacity) {
-    this.map = new HashMap<>();
-    this.head = new Node(-1, -1);
-    this.tail = new Node(-1, -1);
-    head.next = tail;
-    tail.prev = head;
-    this.capacity = capacity;
-  }
+    private void updateExistingKey(int key, int value) {
+        Node node = map.get(key);
+        Node updatedNode = new Node(key, value);
+        removeNode(node);
+        addToFront(updatedNode);
+        map.put(key, updatedNode);
+    }
 
-  public int get(int key) {
-    if (!this.map.containsKey(key)) {
-      return -1;
+    private void removeNode(Node node) {
+        Node prevToNode = node.prev;
+        Node nextToNode = node.next;
+        prevToNode.next = nextToNode;
+        nextToNode.prev = prevToNode;
     }
-    Node node = this.map.get(key);
-    removeNode(node);
-    addNode(node);
-    return this.map.get(key).val;
-  }
 
-  public void put(int key, int value) {
-    if (!map.containsKey(key)) {
-      if (capacity == 0) {
-        removeNode(tail.prev);
-      }
-    } else {
-      removeNode(this.map.get(key));
+    private void addToFront(Node node) {
+        Node nextToHead = head.next;
+        node.next = nextToHead;
+        nextToHead.prev = node;
+        node.prev = head;
+        head.next = node;
     }
-    addNode(new Node(key, value));
-  }
-  
-  private void addNode(Node node) {
-    Node nextToHead = head.next;
-    head.next = node;
-    node.next = nextToHead;
-    nextToHead.prev = node;
-    node.prev = head;
-    this.map.put(node.key, node);
-    this.capacity--;
-  }
-  
-  private void removeNode(Node node) {
-    Node nextNode = node.next;
-    node.prev.next = nextNode;
-    nextNode.prev = node.prev;
-    this.map.remove(node.key);
-    this.capacity++;
-  }
 
-  private static class Node {
-    Node next;
-    Node prev;
-    int key;
-    int val;
+    private static class Node {
 
-    public Node(int key, int val) {
-      this.key = key;
-      this.val = val;
-      this.next = null;
-      this.prev = null;
+        private final int key;
+        private final int value;
+        private Node next;
+        private Node prev;
+        
+        public Node(int key, int value) {
+            this.key = key;
+            this.value = value;
+        }
     }
-  }
 }
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * LRUCache obj = new LRUCache(capacity);
+ * int param_1 = obj.get(key);
+ * obj.put(key,value);
+ */

From 77437e8516b3faa064f9b17fdb0ee5c7bb651cf9 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 19 Jul 2023 06:14:02 -0700
Subject: [PATCH 1746/2175] Added Non-overlapping Intervals.java

---
 Medium/Non Overlapping Intervals.java | 17 -----------------
 Medium/Non-overlapping Intervals.java | 17 +++++++++++++++++
 2 files changed, 17 insertions(+), 17 deletions(-)
 delete mode 100644 Medium/Non Overlapping Intervals.java
 create mode 100644 Medium/Non-overlapping Intervals.java

diff --git a/Medium/Non Overlapping Intervals.java b/Medium/Non Overlapping Intervals.java
deleted file mode 100644
index cbdae574..00000000
--- a/Medium/Non Overlapping Intervals.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-  public int eraseOverlapIntervals(int[][] intervals) {
-    if (intervals.length == 0) {
-      return 0;
-    }
-    Arrays.sort(intervals, Comparator.comparingInt(o -> o[1]));
-    int notRemoved = 1;
-    int end = intervals[0][1];
-    for (int i = 1; i < intervals.length; i++) {
-      if (intervals[i][0] >= end) {
-        notRemoved++;
-        end = intervals[i][1];
-      }
-    }
-    return intervals.length - notRemoved;
-  }
-}
diff --git a/Medium/Non-overlapping Intervals.java b/Medium/Non-overlapping Intervals.java
new file mode 100644
index 00000000..c403b5ed
--- /dev/null
+++ b/Medium/Non-overlapping Intervals.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[1]));
+        int result = 0;
+        int minEndTime = Integer.MIN_VALUE;
+        for (int i = 0; i < intervals.length; i++) {
+            int start = intervals[i][0];
+            int end = intervals[i][1];
+            if (start >= minEndTime) {
+                minEndTime = end;
+            } else {
+                result++;
+            }
+        }
+        return result;
+    }
+}

From 030ccf5ff473cd0e0a80662abeddb6e0869637c3 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 19 Jul 2023 18:27:58 -0700
Subject: [PATCH 1747/2175] Updated Asteroid Collision.java

---
 Medium/Asteroid Collision.java | 49 +++++++++++++++++++---------------
 1 file changed, 28 insertions(+), 21 deletions(-)

diff --git a/Medium/Asteroid Collision.java b/Medium/Asteroid Collision.java
index f739ff48..64a10bf3 100644
--- a/Medium/Asteroid Collision.java	
+++ b/Medium/Asteroid Collision.java	
@@ -1,26 +1,33 @@
 class Solution {
-  public int[] asteroidCollision(int[] asteroids) {
-    Stack<Integer> stack = new Stack<>();
-    for (int asteroid : asteroids) {
-      if (asteroid < 0) {
-        while (!stack.isEmpty() && stack.peek() > 0 && stack.peek() < Math.abs(asteroid)) {
-          stack.pop();
+    public int[] asteroidCollision(int[] asteroids) {
+        List<Integer> result = new ArrayList<>();
+        int idx = 0;
+        while (idx < asteroids.length && asteroids[idx] < 0) {
+            result.add(asteroids[idx++]);
         }
-        if (!stack.isEmpty() && stack.peek() > 0) {
-          if (stack.peek() == Math.abs(asteroid)) {
-            stack.pop();
-          }
-        } else {
-          stack.push(asteroid);
+        while (idx < asteroids.length) {
+            if (asteroids[idx] > 0) {
+                result.add(asteroids[idx++]);
+            } else {
+                if (result.isEmpty() || result.get(result.size() - 1) < 0) {
+                    result.add(asteroids[idx]);
+                } else {
+                    while (!result.isEmpty() && 
+                           result.get(result.size() - 1) > 0 && 
+                           result.get(result.size() - 1) < Math.abs(asteroids[idx])) {
+                        result.remove(result.size() - 1);
+                    }
+                    if (!result.isEmpty() && result.get(result.size() - 1) > 0) {
+                        if (result.get(result.size() - 1) == Math.abs(asteroids[idx])) {
+                            result.remove(result.size() - 1);
+                        } 
+                    } else {
+                        result.add(asteroids[idx]);
+                    }
+                }
+                idx++;
+            }
         }
-      } else {
-        stack.push(asteroid);
-      }
+        return result.stream().mapToInt(Integer::valueOf).toArray();
     }
-    int[] result = new int[stack.size()];
-    for (int i = result.length - 1; i >= 0; i--) {
-      result[i] = stack.pop();
-    }
-    return result;
-  }
 }

From af2dcca53ab3bc59f08bd7fbcb62e1ebe600f472 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 22 Jul 2023 17:54:40 -0700
Subject: [PATCH 1748/2175] Added Check if Array is Good.java

---
 Easy/Check if Array is Good.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Easy/Check if Array is Good.java

diff --git a/Easy/Check if Array is Good.java b/Easy/Check if Array is Good.java
new file mode 100644
index 00000000..f0b86ddc
--- /dev/null
+++ b/Easy/Check if Array is Good.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public boolean isGood(int[] nums) {
+        if (nums.length <= 1) {
+            return false;
+        }
+        int n = nums.length - 1;
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        for (int i = 1; i <= n; i++) {
+            if (!map.containsKey(i)) {
+                return false;
+            }
+            if (map.get(i) > 1 && i != n) {
+                return false;
+            }
+            if (i == n && map.get(i) != 2) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From 21cc646c90cf987d73508826557ab82bb150f205 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sat, 22 Jul 2023 18:33:40 -0700
Subject: [PATCH 1749/2175] Updated Ternary Expression Parser.java

---
 Medium/Ternary Expression Parser.java | 36 ++++++++++++---------------
 1 file changed, 16 insertions(+), 20 deletions(-)

diff --git a/Medium/Ternary Expression Parser.java b/Medium/Ternary Expression Parser.java
index c0079881..6798336d 100644
--- a/Medium/Ternary Expression Parser.java	
+++ b/Medium/Ternary Expression Parser.java	
@@ -1,23 +1,19 @@
 class Solution {
-  public String parseTernary(String expression) {
-    if (expression == null || expression.length() == 0) {
-      return "";
+    public String parseTernary(String expression) {
+        Stack<Character> stack = new Stack<>();
+        int idx = expression.length() - 1;
+        while (idx >= 0) {
+            char c = expression.charAt(idx);
+            if (c >= '0' && c <= '9' || c == 'T' || c == 'F') {
+                stack.push(c);
+            } else if (c == '?') {
+                char trueValue = stack.pop();
+                char falseValue = stack.pop();
+                stack.push(expression.charAt(idx - 1) == 'T' ? trueValue : falseValue);
+                idx--;
+            }
+            idx--;
+        }
+        return String.valueOf(stack.pop());
     }
-    Deque<Character> stack = new LinkedList<>();
-    int n = expression.length();
-    for (int i = n - 1; i >= 0; i--) {
-      char c = expression.charAt(i);
-      if (!stack.isEmpty() && stack.peek() == '?') {
-        stack.pop();  // Pop ?
-        char first = stack.pop();
-        stack.pop();  // Pop :
-        char second = stack.pop();
-        stack.push(c == 'T' ? first : second);
-      }
-      else {
-        stack.push(c);
-      }
-    }
-    return String.valueOf(stack.peek());
-  }
 }

From 4feb8fec7c911f0370d16c68290d6cf54b6f9e49 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Sun, 23 Jul 2023 09:05:40 -0700
Subject: [PATCH 1750/2175] Added Split Strings by Separator.java

---
 Easy/Split Strings by Separator.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Split Strings by Separator.java

diff --git a/Easy/Split Strings by Separator.java b/Easy/Split Strings by Separator.java
new file mode 100644
index 00000000..2292a309
--- /dev/null
+++ b/Easy/Split Strings by Separator.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public List<String> splitWordsBySeparator(List<String> words, char separator) {
+        List<String> result = new ArrayList<>();
+        for (String word : words) {
+            int startIdx = 0;
+            int currIdx = 0;
+            while (currIdx < word.length()) {
+                if (word.charAt(currIdx) == separator) {
+                    if (currIdx - startIdx > 0) {
+                        result.add(word.substring(startIdx, currIdx));
+                    }
+                    startIdx = currIdx + 1;
+                }
+                currIdx++;
+            }
+            if (currIdx - startIdx > 0) {
+                result.add(word.substring(startIdx, currIdx));
+            }
+        }
+        return result;
+    }
+}

From 9cfef955c90e6afd14d08cc15b492c424b720e76 Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Mon, 24 Jul 2023 17:58:41 -0700
Subject: [PATCH 1751/2175] Added Peak Index in a Mountain Array.java

---
 Easy/Peak Index in a Mountain Array.java   | 16 ----------------
 Medium/Peak Index in a Mountain Array.java | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 16 deletions(-)
 delete mode 100644 Easy/Peak Index in a Mountain Array.java
 create mode 100644 Medium/Peak Index in a Mountain Array.java

diff --git a/Easy/Peak Index in a Mountain Array.java b/Easy/Peak Index in a Mountain Array.java
deleted file mode 100644
index 818dbf9c..00000000
--- a/Easy/Peak Index in a Mountain Array.java	
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution {
-  public int peakIndexInMountainArray(int[] A) {
-    int low = 0;
-    int high = A.length - 1;
-    while (low < high) {
-      int mid = low + (high - low) / 2;
-      if (A[mid] < A[mid + 1]) {
-        low = mid + 1;
-      }
-      else {
-        high = mid;
-      }
-    }
-    return low;
-  }
-}
diff --git a/Medium/Peak Index in a Mountain Array.java b/Medium/Peak Index in a Mountain Array.java
new file mode 100644
index 00000000..d496f7c4
--- /dev/null
+++ b/Medium/Peak Index in a Mountain Array.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int peakIndexInMountainArray(int[] arr) {
+        int start = 0;
+        int end = arr.length - 1;
+        while (start < end) {
+            int mid = (start + end) / 2;
+            if (arr[mid] < arr[mid + 1]) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        return start;
+    }
+}

From 6b73d50956da22787d7ca4d16a54d7ba11d79469 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 25 Jul 2023 18:44:14 -0700
Subject: [PATCH 1752/2175] Create Minimum Speed to Arrive on Time.java

---
 Medium/Minimum Speed to Arrive on Time.java | 26 +++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Minimum Speed to Arrive on Time.java

diff --git a/Medium/Minimum Speed to Arrive on Time.java b/Medium/Minimum Speed to Arrive on Time.java
new file mode 100644
index 00000000..c5751902
--- /dev/null
+++ b/Medium/Minimum Speed to Arrive on Time.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int minSpeedOnTime(int[] dist, double hour) {
+        int start = 1;
+        int end = 1000_000_0;
+        int minSpeed = -1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (isPossible(dist, mid, hour)) {
+                minSpeed = mid;
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return minSpeed;
+    }
+    
+    private boolean isPossible(int[] dist, int speed, double hour) {
+        double totalTime = 0.0;
+        for (int i = 0; i < dist.length; i++) {
+            double time = (double) dist[i] / (double) speed;
+            totalTime += (i == dist.length - 1 ? time : Math.ceil(time));
+        }
+        return totalTime <= hour;
+    }
+}

From c04e0a8bb8873c44f4c56618153c538598536d60 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Jul 2023 08:30:30 -0700
Subject: [PATCH 1753/2175] Create Number of Employees Who Met the Target.java

---
 Easy/Number of Employees Who Met the Target.java | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Easy/Number of Employees Who Met the Target.java

diff --git a/Easy/Number of Employees Who Met the Target.java b/Easy/Number of Employees Who Met the Target.java
new file mode 100644
index 00000000..64f20287
--- /dev/null
+++ b/Easy/Number of Employees Who Met the Target.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int numberOfEmployeesWhoMetTarget(int[] hours, int target) {
+        return (int) Arrays.stream(hours).filter(hour -> hour >= target).count();
+    }
+}

From 51074092e35e2cdeb1559819326cea0d3480f512 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Jul 2023 08:31:03 -0700
Subject: [PATCH 1754/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index dd9ecf17..79190be6 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 1300+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1400+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count

From 5ca5bfc1ae8f36abe3b47301a0744ed971dbf395 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 31 Jul 2023 17:52:05 -0700
Subject: [PATCH 1755/2175] Update Combinations.java

---
 Medium/Combinations.java | 38 +++++++++++++++++---------------------
 1 file changed, 17 insertions(+), 21 deletions(-)

diff --git a/Medium/Combinations.java b/Medium/Combinations.java
index f5d99e2b..425b44ff 100644
--- a/Medium/Combinations.java
+++ b/Medium/Combinations.java
@@ -1,26 +1,22 @@
 class Solution {
-  public List<List<Integer>> combine(int n, int k) {
-    List<List<Integer>> ans = new ArrayList<>();
-    List<Integer> curr = new ArrayList<>();
-    helper(ans, curr, new boolean[n], k, 0);
-    return ans;
-  }
-  
-  private void helper(List<List<Integer>> ans, List<Integer> curr, boolean[] visited, int k, int idx) {
-    if (curr.size() == k) {
-      ans.add(new ArrayList<>(curr));
+    public List<List<Integer>> combine(int n, int k) {
+        List<List<Integer>> result = new ArrayList<>();
+        helper(result, n, k, new ArrayList<>(), 1);
+        return result;
     }
-    else {
-      for (int i = idx; i < visited.length; i++) {
-        if (visited[i]) {
-          continue;
+
+    private void helper(List<List<Integer>> result, int n, int k, List<Integer> curr, int currValue) {
+        if (curr.size() == k) {
+            result.add(new ArrayList<>(curr));
+            return;
+        }
+        for (int i = currValue; i <= n; i++) {
+            if (!curr.isEmpty() && curr.get(curr.size() - 1) >= i) {
+                continue;
+            }
+            curr.add(i);
+            helper(result, n, k, curr, currValue + 1);
+            curr.remove(curr.size() - 1);
         }
-        curr.add(i + 1);
-        visited[i] = true;
-        helper(ans, curr, visited, k, i + 1);
-        curr.remove(curr.size() - 1);
-        visited[i] = false;
-      }
     }
-  }
 }

From 948b2fc4bbc7a43cae264bcb911ef6486683a52e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Aug 2023 17:47:26 -0700
Subject: [PATCH 1756/2175] Update Permutations.java

---
 Medium/Permutations.java | 40 +++++++++++++++++++++-------------------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/Medium/Permutations.java b/Medium/Permutations.java
index 760b7452..61c86f42 100644
--- a/Medium/Permutations.java
+++ b/Medium/Permutations.java
@@ -1,23 +1,25 @@
 class Solution {
-  public List<List<Integer>> permute(int[] nums) {
-    List<List<Integer>> result = new ArrayList<>();
-    helper(nums, result, new ArrayList<>(), new boolean[nums.length]);
-    return result;
-  }
-  
-  private void helper(int[] nums, List<List<Integer>> result, List<Integer> curr, boolean[] visited) {
-    if (curr.size() == nums.length) {
-      result.add(new ArrayList<>(curr));
-    } else {
-      for (int i = 0; i < nums.length; i++) {
-        if (!visited[i]) {
-          visited[i] = true;
-          curr.add(nums[i]);
-          helper(nums, result, curr, visited);
-          visited[i] = false;
-          curr.remove(curr.size() - 1);
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        Set<Integer> visited = new HashSet<>();
+        permute(nums, result, new ArrayList<>(), visited);
+        return result;
+    }
+    
+    private void permute(int[] nums, List<List<Integer>> result, List<Integer> curr, Set<Integer> visited) {
+        if (curr.size() == nums.length) {
+            result.add(new ArrayList<>(curr));
+            return;
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (visited.contains(nums[i])) {
+                continue;
+            }
+            visited.add(nums[i]);
+            curr.add(nums[i]);
+            permute(nums, result, curr, visited);
+            visited.remove(nums[i]);
+            curr.remove(curr.size() - 1);
         }
-      }
     }
-  }
 }

From f9008e0defd3aae742e88bd0126eb72ab47d0818 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Aug 2023 11:24:25 -0700
Subject: [PATCH 1757/2175] Update Letter Combinations of a Phone Number.java

---
 ...Letter Combinations of a Phone Number.java | 51 +++++++++++--------
 1 file changed, 29 insertions(+), 22 deletions(-)

diff --git a/Medium/Letter Combinations of a Phone Number.java b/Medium/Letter Combinations of a Phone Number.java
index 2c3a8c23..b145954b 100644
--- a/Medium/Letter Combinations of a Phone Number.java	
+++ b/Medium/Letter Combinations of a Phone Number.java	
@@ -1,25 +1,32 @@
 class Solution {
-  
-  private final List<String> LETTER_MAPPING = Arrays.asList("abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz");
-  
-  public List<String> letterCombinations(String digits) {
-    List<String> result = new ArrayList<>();
-    helper(digits, 0, new StringBuilder(), result);
-    return result;
-  }
-  
-  private void helper(String digits, int idx, StringBuilder sb, List<String> result) {
-    if (idx == digits.length()) {
-      if (sb.length() > 0) {
-        result.add(new String(sb.toString()));
-      }
-      return;
-    } 
-    int mappingIdx = Character.getNumericValue(digits.charAt(idx)) - 2;
-    for (char c : LETTER_MAPPING.get(mappingIdx).toCharArray()) {
-      sb.append(c);
-      helper(digits, idx + 1, sb, result);
-      sb.deleteCharAt(sb.length() - 1);
+    private static final Map<Character, String> DIGIT_TO_CHAR_MAPPING = Map.of(
+            '2', "abc",
+            '3', "def",
+            '4', "ghi",
+            '5', "jkl",
+            '6', "mno",
+            '7', "pqrs",
+            '8', "tuv",
+            '9', "wxyz"
+    );
+
+    public List<String> letterCombinations(String digits) {
+        List<String> result = new ArrayList<>();
+        letterCombinations(digits, 0, new StringBuilder(), result);
+        return result;
+    }
+
+    private void letterCombinations(String digits, int idx, StringBuilder sb, List<String> result) {
+        if (idx == digits.length()) {
+            if (!sb.isEmpty()) {
+                result.add(sb.toString());
+            }
+            return;
+        }
+        for (char c : DIGIT_TO_CHAR_MAPPING.get(digits.charAt(idx)).toCharArray()) {
+            sb.append(c);
+            letterCombinations(digits, idx + 1, sb, result);
+            sb.deleteCharAt(sb.length() - 1);
+        }
     }
-  }
 }

From 786047b7d738f735525f7ad5b418c902e52e2f20 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 5 Aug 2023 18:36:51 -0700
Subject: [PATCH 1758/2175] Create Account Balance After Rounded Purchase.java

---
 Easy/Account Balance After Rounded Purchase.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Account Balance After Rounded Purchase.java

diff --git a/Easy/Account Balance After Rounded Purchase.java b/Easy/Account Balance After Rounded Purchase.java
new file mode 100644
index 00000000..3342d18d
--- /dev/null
+++ b/Easy/Account Balance After Rounded Purchase.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public int accountBalanceAfterPurchase(int purchaseAmount) {
+        if (purchaseAmount % 10 >= 5) {
+            purchaseAmount += 10 - purchaseAmount % 10;
+        } else {
+            purchaseAmount -= purchaseAmount % 10;
+        }
+        return 100 - purchaseAmount;
+    }
+}

From 6775fadb7f0d45f1eb7e2e44c87b2169280e6eec Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 6 Aug 2023 07:51:35 -0700
Subject: [PATCH 1759/2175] Create Faulty Keyboard.java

---
 Easy/Faulty Keyboard.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Faulty Keyboard.java

diff --git a/Easy/Faulty Keyboard.java b/Easy/Faulty Keyboard.java
new file mode 100644
index 00000000..500dc39b
--- /dev/null
+++ b/Easy/Faulty Keyboard.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public String finalString(String s) {
+        Deque<Character> deque = new ArrayDeque<>();
+        boolean flip = false;
+        for (char c : s.toCharArray()) {
+            if (c == 'i') {
+                flip = !flip;
+            } else {
+                if (flip) {
+                    deque.addFirst(c);
+                } else {
+                    deque.addLast(c);
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char c : deque){
+            sb.append(c);
+        }
+        return flip ? sb.reverse().toString() : sb.toString();
+    }
+}

From b44f362cb1c8add8f1f9a616c6e9ee77fcd1b842 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Aug 2023 06:40:10 -0700
Subject: [PATCH 1760/2175] Update Search a 2D Matrix.java

---
 Medium/Search a 2D Matrix.java | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/Medium/Search a 2D Matrix.java b/Medium/Search a 2D Matrix.java
index e7de2a1f..086454e0 100644
--- a/Medium/Search a 2D Matrix.java	
+++ b/Medium/Search a 2D Matrix.java	
@@ -1,21 +1,21 @@
 class Solution {
-  public boolean searchMatrix(int[][] matrix, int target) {
-    int rowIdx = matrix.length - 1;
-    int colIdx = matrix[0].length - 1;
-    while (rowIdx >= 0 && colIdx >= 0) {
-      if (matrix[rowIdx][colIdx] == target) {
-        return true;
-      }
-      if (matrix[rowIdx][colIdx] > target) {
-        colIdx--;
-        if (colIdx < 0) {
-          colIdx = matrix[0].length - 1;
-          rowIdx--;
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int row = matrix.length - 1;
+        int col = matrix[0].length - 1;
+        while (row >= 0 && col >= 0) {
+            if (matrix[row][col] == target) {
+                return true;
+            }
+            if (matrix[row][col] > target) {
+                col--;
+                if (col < 0) {
+                    col = matrix[0].length - 1;
+                    row--;
+                }
+            } else {
+                row--;
+            }
         }
-      } else {
-        rowIdx--;
-      }
+        return false;
     }
-    return false;
-  }
 }

From 632f7892d835aa73b69cc100c0be01b64b6bcf09 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Aug 2023 06:48:18 -0700
Subject: [PATCH 1761/2175] Create Insert Greatest Common Divisors in Linked
 List.java

---
 ...eatest Common Divisors in Linked List.java | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Insert Greatest Common Divisors in Linked List.java

diff --git a/Medium/Insert Greatest Common Divisors in Linked List.java b/Medium/Insert Greatest Common Divisors in Linked List.java
new file mode 100644
index 00000000..6dcf5fd0
--- /dev/null
+++ b/Medium/Insert Greatest Common Divisors in Linked List.java	
@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode insertGreatestCommonDivisors(ListNode head) {
+        ListNode curr = head;
+        while (curr != null && curr.next != null) {
+            ListNode gcdNode = new ListNode(findGcd(curr.val, curr.next.val));
+            gcdNode.next = curr.next;
+            curr.next = gcdNode;
+            curr = gcdNode.next;
+        }
+        return head;
+    }
+    
+    private static int findGcd(int numOne, int numTwo) {
+        if (numOne == numTwo) {
+            return numOne;
+        }
+        return numOne > numTwo ? findGcd(numOne - numTwo, numTwo) : findGcd(numOne, numTwo - numOne);
+    }
+}

From ff3e17292ea34d3355e30e177ce06c6cc19ac742 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Aug 2023 13:43:37 -0700
Subject: [PATCH 1762/2175] Create Minimize the Maximum Difference of
 Pairs.java

---
 ...imize the Maximum Difference of Pairs.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Medium/Minimize the Maximum Difference of Pairs.java

diff --git a/Medium/Minimize the Maximum Difference of Pairs.java b/Medium/Minimize the Maximum Difference of Pairs.java
new file mode 100644
index 00000000..5ec67591
--- /dev/null
+++ b/Medium/Minimize the Maximum Difference of Pairs.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int minimizeMax(int[] nums, int p) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int start = 0;
+        int end = nums[n - 1] - nums[0];
+        while (start < end) {
+            int mid = (start + end) / 2;
+            if (countValidPairs(nums, mid) >= p) {
+                end = mid;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return start;
+    }
+    
+    private static int countValidPairs(int[] nums, int limit) {
+        int idx = 0;
+        int count = 0;
+        while (idx < nums.length - 1) {
+            if (nums[idx + 1] - nums[idx] <= limit) {
+                count++;
+                idx++;
+            }
+            idx++;
+        }
+        return count;
+    }
+}

From 6e45a6a2254b08182704b42abeabb7b151ce9cb8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Aug 2023 10:02:12 -0700
Subject: [PATCH 1763/2175] Update Search in Rotated Sorted Array II.java

---
 Medium/Search in Rotated Sorted Array II.java | 48 +++++++++----------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/Medium/Search in Rotated Sorted Array II.java b/Medium/Search in Rotated Sorted Array II.java
index 65081528..bcb34f99 100644
--- a/Medium/Search in Rotated Sorted Array II.java	
+++ b/Medium/Search in Rotated Sorted Array II.java	
@@ -1,28 +1,28 @@
 class Solution {
-  public boolean search(int[] nums, int target) {
-    int start = 0;
-    int end = nums.length - 1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (nums[mid] == target) {
-        return true;
-      }
-      if (nums[mid] < nums[end] || nums[mid] < nums[start]) {
-        if (target > nums[mid] && target <= nums[end]) {
-          start = mid + 1;
-        } else {
-          end = mid - 1;
+    public boolean search(int[] nums, int target) {
+        int start = 0;
+        int end = nums.length - 1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (nums[mid] == target) {
+                return true;
+            }
+            if (nums[mid] < nums[end] || nums[mid] < nums[start]) {
+                if (target > nums[mid] && target <= nums[end]) {
+                    start = mid + 1;
+                } else {
+                    end = mid - 1;
+                }
+            } else if (nums[mid] > nums[start] || nums[mid] > nums[end]) {
+                if (target < nums[mid] && target >= nums[start]) {
+                    end = mid - 1;
+                } else {
+                    start = mid + 1;
+                }
+            } else {
+                end--;
+            }
         }
-      } else if (nums[mid] > nums[start] || nums[mid] > nums[end]) {
-        if (target < nums[mid] && target >= nums[start]) {
-          end = mid - 1;
-        } else {
-          start = mid + 1;
-        }
-      } else {
-        end--;
-      }
+        return false;
     }
-    return false;
-  }
 }

From de9e6a09d0537b777eddbc4de9870c538d2a9d68 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Aug 2023 06:41:55 -0700
Subject: [PATCH 1764/2175] Create Max Pair Sum in an Array.java

---
 Easy/Max Pair Sum in an Array.java | 54 ++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 Easy/Max Pair Sum in an Array.java

diff --git a/Easy/Max Pair Sum in an Array.java b/Easy/Max Pair Sum in an Array.java
new file mode 100644
index 00000000..e7f6332e
--- /dev/null
+++ b/Easy/Max Pair Sum in an Array.java	
@@ -0,0 +1,54 @@
+class Solution {
+    public int maxSum(int[] nums) {
+        Map<Integer, Pair> map = new HashMap<>();
+        for (int num : nums) {
+            int maxDigit = getMaxDigit(num);
+            if (!map.containsKey(maxDigit)) {
+                map.put(maxDigit, new Pair());
+            }
+            map.get(maxDigit).record(num);
+        }
+        int result = -1;
+        for (Integer key : map.keySet()) {
+            result = Math.max(result, map.get(key).getPairSum());
+        }
+        return result;
+    }
+    
+    private int getMaxDigit(int num) {
+        int maxDigit = 0;
+        while (num > 0) {
+            maxDigit = Math.max(maxDigit, num % 10);
+            num /= 10;
+        }
+        return maxDigit;
+    }
+    
+    private static class Pair {
+        int maximum;
+        int secondMaximum;
+        
+        public Pair() {
+            maximum = -1;
+            secondMaximum = -1;
+        }
+        
+        public void record(int num) {
+            if (maximum < num) {
+                if (secondMaximum < maximum) {
+                    secondMaximum = maximum;
+                }
+                maximum = num;
+            } else if (secondMaximum < num) {
+                secondMaximum = num;
+            }
+        }
+        
+        public int getPairSum() {
+            if (maximum == -1 || secondMaximum == -1) {
+                return -1;
+            }
+            return maximum + secondMaximum;
+        }
+    }
+}

From 3b753db3d0ca7a0be5b210cfa4dbea592d83ebde Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Aug 2023 13:53:41 -0700
Subject: [PATCH 1765/2175] Update Partition List.java

---
 Medium/Partition List.java | 59 ++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 31 deletions(-)

diff --git a/Medium/Partition List.java b/Medium/Partition List.java
index bb1f9dcf..a807608c 100644
--- a/Medium/Partition List.java	
+++ b/Medium/Partition List.java	
@@ -9,38 +9,35 @@
  * }
  */
 class Solution {
-  public ListNode partition(ListNode head, int x) {
-    ListNode lessThanHead = null;
-    ListNode lessThan = null;
-    ListNode greaterThan = null;
-    ListNode greaterThanHead = null;
-    while (head != null) {
-      ListNode nextNode = head.next;
-      if (head.val < x) {
-        if (lessThan == null) {
-          lessThan = head;
-          lessThanHead = lessThan;
-        } else {
-          lessThan.next = head;
-          lessThan = lessThan.next;
+    public ListNode partition(ListNode head, int x) {
+        ListNode lessHead = null;
+        ListNode lessCurr = null;
+        ListNode greaterHead = null;
+        ListNode greaterCurr = null;
+        while (head != null) {
+            if (head.val < x) {
+                if (lessCurr == null) {
+                    lessCurr = new ListNode(head.val);
+                    lessHead = lessCurr;
+                } else {
+                    lessCurr.next = new ListNode(head.val);
+                    lessCurr = lessCurr.next;
+                }
+            } else {
+                if (greaterCurr == null) {
+                    greaterCurr = new ListNode(head.val);
+                    greaterHead = greaterCurr;
+                } else {
+                    greaterCurr.next = new ListNode(head.val);
+                    greaterCurr = greaterCurr.next;
+                }
+            }
+            head = head.next;
         }
-        lessThan.next = null;
-      } else {
-        if (greaterThan == null) {
-          greaterThan = head;
-          greaterThanHead = greaterThan;
-        } else {
-          greaterThan.next = head;
-          greaterThan = greaterThan.next;
+        if (lessHead == null) {
+            return greaterHead;
         }
-        greaterThan.next = null;
-      }
-      head = nextNode;
+        lessCurr.next = greaterHead;
+        return lessHead;
     }
-    if (lessThanHead == null || greaterThanHead == null) {
-      return lessThan == null ? greaterThanHead : lessThanHead;
-    }
-    lessThan.next = greaterThanHead;
-    return lessThanHead;
-  }
 }

From 265791bdf2285190ac5b840c708804856701c679 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 16 Aug 2023 11:51:52 -0700
Subject: [PATCH 1766/2175] Update Sliding Window Maximum.java

---
 Hard/Sliding Window Maximum.java | 25 +++++++++----------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/Hard/Sliding Window Maximum.java b/Hard/Sliding Window Maximum.java
index 2aafc22d..635720b8 100644
--- a/Hard/Sliding Window Maximum.java	
+++ b/Hard/Sliding Window Maximum.java	
@@ -1,25 +1,18 @@
 class Solution {
     public int[] maxSlidingWindow(int[] nums, int k) {
+        Deque<Integer> dequeue = new ArrayDeque<>();
         int[] result = new int[nums.length - k + 1];
-        int start = 0;
-        int end = 0;
-        Deque<Integer> queue = new ArrayDeque<>();
-        while (end < nums.length) {
-            // Remove elements from end of  queue as long as the value at end of queue is less
-            // than the current value
-            while (!queue.isEmpty() && nums[queue.peekLast()] < nums[end]) {
-                queue.removeLast();
+        for (int i = 0; i < nums.length; i++) {
+            if (!dequeue.isEmpty() && dequeue.getFirst() == i - k) {
+                dequeue.removeFirst();
             }
-            queue.add(end);
-            // Remove the first element from the queue if we have already passed it in our range
-            if (start > queue.peekFirst()) {
-                queue.removeFirst();
+            while (!dequeue.isEmpty() && nums[i] > nums[dequeue.getLast()]) {
+                dequeue.removeLast();
             }
-            // Update result if our window is at least of size k
-            if (end + 1 >= k) {
-                result[start++] = nums[queue.peekFirst()];
+            dequeue.addLast(i);
+            if (i >= k - 1) {
+                result[i - k + 1] = nums[dequeue.getFirst()];
             }
-            end++;
         }
         return result;
     }

From 0568a1ad8acc18f44337c12e043a4bbe103829d8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 18 Aug 2023 09:44:20 -0700
Subject: [PATCH 1767/2175] Update Maximal Network Rank.java

---
 Medium/Maximal Network Rank.java | 34 +++++++++++++++++---------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/Medium/Maximal Network Rank.java b/Medium/Maximal Network Rank.java
index 211a7c8e..e5c3f20c 100644
--- a/Medium/Maximal Network Rank.java	
+++ b/Medium/Maximal Network Rank.java	
@@ -1,19 +1,21 @@
 class Solution {
-  public int maximalNetworkRank(int n, int[][] roads) {
-    boolean[][] connected = new boolean[n][n];
-    int[] count = new int[n];
-    for (int[] road : roads) {
-      count[road[0]]++;
-      count[road[1]]++;
-      connected[road[0]][road[1]] = true;
-      connected[road[1]][road[0]] = true;
+    public int maximalNetworkRank(int n, int[][] roads) {
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        for (int[] road : roads) {
+            map.computeIfAbsent(road[0], k -> new HashSet<>()).add(road[1]);
+            map.computeIfAbsent(road[1], k -> new HashSet<>()).add(road[0]);
+        }
+        int maximumRank = 0;
+        for (int i = 0; i < n; i++) {
+            int iRank = map.getOrDefault(i, new HashSet<>()).size();
+            for (int j = i + 1; j < n; j++) {
+                int combinedRank = iRank + map.getOrDefault(j, new HashSet<>()).size();
+                if (map.getOrDefault(j, new HashSet<>()).contains(i)) {
+                    combinedRank--;
+                }
+                maximumRank = Math.max(maximumRank, combinedRank);
+            }
+        }
+        return maximumRank;
     }
-    int maxCount = 0;
-    for (int i = 0; i < n; i++) {
-      for (int j = i + 1; j < n; j++) {
-        maxCount = Math.max(maxCount, count[i] + count[j] - (connected[i][j] ? 1 : 0));
-      }
-    }
-    return maxCount;
-  }
 }

From 04946d7f6cca3822ae65c6e5d9c1b62a3b9543d3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Aug 2023 12:27:23 -0700
Subject: [PATCH 1768/2175] Create Sort Items by Groups Respecting
 Dependencies.java

---
 ...ems by Groups Respecting Dependencies.java | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 Hard/Sort Items by Groups Respecting Dependencies.java

diff --git a/Hard/Sort Items by Groups Respecting Dependencies.java b/Hard/Sort Items by Groups Respecting Dependencies.java
new file mode 100644
index 00000000..38c531a3
--- /dev/null
+++ b/Hard/Sort Items by Groups Respecting Dependencies.java	
@@ -0,0 +1,62 @@
+class Solution {
+    public int[] sortItems(int n, int m, int[] group, List<List<Integer>> beforeItems) {
+        int groupId = m;
+        for (int i = 0; i < group.length; i++) {
+            if (group[i] == -1) {
+                group[i] = groupId++;
+            }
+        }
+        Map<Integer, List<Integer>> nodeToDependentNodes = new HashMap<>();
+        Map<Integer, List<Integer>> groupToDependentGroups = new HashMap<>();
+        int[] itemIndegree = new int[n];
+        int[] groupIndegree = new int[groupId];
+        for (int i = 0; i < beforeItems.size(); i++) {
+            for (Integer prev : beforeItems.get(i)) {
+                nodeToDependentNodes.computeIfAbsent(prev, k -> new ArrayList<>()).add(i);
+                itemIndegree[i]++;
+                if (group[i] != group[prev]) {
+                    groupToDependentGroups.computeIfAbsent(group[prev], k -> new ArrayList<>()).add(group[i]);
+                    groupIndegree[group[i]]++;
+                }
+            }
+        }
+        List<Integer> itemOrdering = topologicalSort(nodeToDependentNodes, itemIndegree);
+        List<Integer> groupOrdering = topologicalSort(groupToDependentGroups, groupIndegree);
+        if (itemOrdering.isEmpty() || groupOrdering.isEmpty()) {
+            return new int[]{};
+        }
+        Map<Integer, List<Integer>> orderedGroups = new HashMap<>();
+        for (Integer item : itemOrdering) {
+            orderedGroups.computeIfAbsent(group[item], k -> new ArrayList<>()).add(item);
+        }
+        int[] result = new int[n];
+        int idx = 0;
+        for (Integer groupNo : groupOrdering) {
+            for (Integer item : orderedGroups.getOrDefault(groupNo, new ArrayList<>())) {
+                result[idx++] = item;
+            }
+        }
+        return result;
+    }
+    
+    private static List<Integer> topologicalSort(Map<Integer, List<Integer>> graph, int[] indegree) {
+        List<Integer> visited = new ArrayList<>();
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i = 0; i < indegree.length; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            visited.add(removed);
+            for (Integer conn : graph.getOrDefault(removed, new ArrayList<>())) {
+                indegree[conn]--;
+                if (indegree[conn] == 0) {
+                    queue.add(conn);
+                }
+            }
+        }
+        return visited.size() == indegree.length ? visited : new ArrayList<>();
+    }
+}

From cc431382291b2cf01b8dce7088698cd7759dce6e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Aug 2023 17:34:10 -0700
Subject: [PATCH 1769/2175] Update Repeated Substring Pattern.java

---
 Easy/Repeated Substring Pattern.java | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/Easy/Repeated Substring Pattern.java b/Easy/Repeated Substring Pattern.java
index 79ea250c..fc817f7e 100644
--- a/Easy/Repeated Substring Pattern.java	
+++ b/Easy/Repeated Substring Pattern.java	
@@ -1,19 +1,16 @@
 class Solution {
-  public boolean repeatedSubstringPattern(String s) {
-    int n = s.length();
-    for (int i = n / 2; i >= 1; i--) {
-      if (n % i == 0) {
-        int count = n / i;
-        StringBuilder sb = new StringBuilder();
-        String sub = s.substring(0, i);
-        while (count-- > 0) {
-          sb.append(sub);
+    public boolean repeatedSubstringPattern(String s) {
+        int n = s.length();
+        for (int i = n / 2; i > 0; i--) {
+            if (n % i == 0) {
+                int count = n / i;
+                String substring = s.substring(0, i);
+                String repeatedString = substring.repeat(count);
+                if (repeatedString.equals(s)) {
+                    return true;
+                }
+            }
         }
-        if (sb.toString().equals(s)) {
-          return true;
-        }
-      }
+        return false;
     }
-    return false;
-  }
 }

From 36aec1a994a56f82e26f90c46f75696fb3ef8646 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Aug 2023 17:36:41 -0700
Subject: [PATCH 1770/2175] Create Check if a String Is an Acronym of
 Words.java

---
 Easy/Check if a String Is an Acronym of Words.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Check if a String Is an Acronym of Words.java

diff --git a/Easy/Check if a String Is an Acronym of Words.java b/Easy/Check if a String Is an Acronym of Words.java
new file mode 100644
index 00000000..5608783c
--- /dev/null
+++ b/Easy/Check if a String Is an Acronym of Words.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public boolean isAcronym(List<String> words, String s) {
+        StringBuilder sb = new StringBuilder();
+        for (String word : words) {
+            sb.append(word.charAt(0));
+        }
+        return sb.toString().equals(s);
+    }
+}

From 13c88ecbdab6dcac0d33dd7698f12528c6498745 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Aug 2023 07:31:03 -0700
Subject: [PATCH 1771/2175] Create Count Pairs Whose Sum is Less than
 Target.java

---
 ...nt Pairs Whose Sum is Less than Target.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Count Pairs Whose Sum is Less than Target.java

diff --git a/Easy/Count Pairs Whose Sum is Less than Target.java b/Easy/Count Pairs Whose Sum is Less than Target.java
new file mode 100644
index 00000000..90c31c23
--- /dev/null
+++ b/Easy/Count Pairs Whose Sum is Less than Target.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int countPairs(List<Integer> nums, int target) {
+        Collections.sort(nums);
+        int start = 0;
+        int end = nums.size() - 1;
+        int count = 0;
+        while (start < end) {
+            int sum = nums.get(start) + nums.get(end);
+            if (sum < target) {
+                count += end - start;
+                start++;
+            } else {
+                end--;
+            }
+        }
+        return count;
+    }
+}

From 94d6c7631e9ad5154c03b87cec621a02574c7642 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Aug 2023 16:52:21 -0700
Subject: [PATCH 1772/2175] Create Determine the Minimum Sum of a k-avoiding
 Array.java

---
 ... the Minimum Sum of a k-avoiding Array.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Determine the Minimum Sum of a k-avoiding Array.java

diff --git a/Medium/Determine the Minimum Sum of a k-avoiding Array.java b/Medium/Determine the Minimum Sum of a k-avoiding Array.java
new file mode 100644
index 00000000..3eab331f
--- /dev/null
+++ b/Medium/Determine the Minimum Sum of a k-avoiding Array.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int minimumSum(int n, int k) {
+        Set<Integer> set = new HashSet<>();
+        set.add(1);
+        int sum = 1;
+        int next = 2;
+        while (n > 1) {
+            if (set.contains(k - next)) {
+                next++;
+                continue;
+            }
+            set.add(next);
+            sum += next++;
+            n--;
+        }
+        return sum;
+    }
+}

From 3ab5cb5cc7d9c0d0826268f91ef150d50333c5b6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 22 Aug 2023 17:00:54 -0700
Subject: [PATCH 1773/2175] Create Make String a Subsequence Using Cyclic
 Increments.java

---
 ... a Subsequence Using Cyclic Increments.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Make String a Subsequence Using Cyclic Increments.java

diff --git a/Medium/Make String a Subsequence Using Cyclic Increments.java b/Medium/Make String a Subsequence Using Cyclic Increments.java
new file mode 100644
index 00000000..1247a755
--- /dev/null
+++ b/Medium/Make String a Subsequence Using Cyclic Increments.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean canMakeSubsequence(String str1, String str2) {
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < str1.length() && idxTwo < str2.length()) {
+            if (str1.charAt(idxOne) == str2.charAt(idxTwo) ||
+                nextCyclicChar(str1.charAt(idxOne)) == str2.charAt(idxTwo)) {
+                idxTwo++;
+            } 
+            idxOne++;
+        }
+        return idxTwo == str2.length();
+    }
+    
+    private static char nextCyclicChar(char c) {
+        return c == 'z' ? 'a' : (char) (c + 1);
+    }
+}

From 8c4f2cfb09055746c83be881ed85de019ee11c03 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Aug 2023 13:12:46 -0700
Subject: [PATCH 1774/2175] Update Maximum Length of Pair Chain.java

---
 Medium/Maximum Length of Pair Chain.java | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/Medium/Maximum Length of Pair Chain.java b/Medium/Maximum Length of Pair Chain.java
index 1ad30427..cb98b670 100644
--- a/Medium/Maximum Length of Pair Chain.java	
+++ b/Medium/Maximum Length of Pair Chain.java	
@@ -1,22 +1,14 @@
 class Solution {
     public int findLongestChain(int[][] pairs) {
-        Arrays.sort(pairs, new Comparator<int[]>() {
-            @Override
-            public int compare(int[] o1, int[] o2) {
-                return o1[0] - o2[0];
-            }
-        });
-
-        int[] temp = new int[pairs.length];
-        Arrays.fill(temp, 1);
-        for (int i=1; i<pairs.length; i++) {
-            for (int j=0; j<i; j++) {
-                if (pairs[j][1] < pairs[i][0]) {
-                    temp[i] = Math.max(temp[i], temp[j] + 1);
-                }
+        Arrays.sort(pairs, Comparator.comparingInt(a -> a[1]));
+        int curr = Integer.MIN_VALUE;
+        int result = 0;
+        for (int[] pair : pairs) {
+            if (pair[0] > curr) {
+                result++;
+                curr = pair[1];
             }
         }
-
-        return Arrays.stream(temp).max().getAsInt();
+        return result;
     }
 }

From d68bc4f512443e0d54e7e32f5d95c48871b3fc57 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Aug 2023 07:17:35 -0700
Subject: [PATCH 1775/2175] Create Furthest Point From Origin.java

---
 Easy/Furthest Point From Origin.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Furthest Point From Origin.java

diff --git a/Easy/Furthest Point From Origin.java b/Easy/Furthest Point From Origin.java
new file mode 100644
index 00000000..d7abca92
--- /dev/null
+++ b/Easy/Furthest Point From Origin.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int furthestDistanceFromOrigin(String moves) {
+        int emptyCount = 0;
+        int direction = 0;
+        for (char c : moves.toCharArray()) {
+            if (c == '_') {
+                emptyCount++;
+            } else {
+                direction += c == 'L' ? -1 : 1;
+            }
+        }
+        return Math.abs(direction) + emptyCount;
+    }
+}

From 92023ae957e8647e1b4fdae4ff444b17ec54878c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Aug 2023 17:44:26 -0700
Subject: [PATCH 1776/2175] Update Implement Stack using Queues.java

---
 Easy/Implement Stack using Queues.java | 87 +++++++++++++-------------
 1 file changed, 43 insertions(+), 44 deletions(-)

diff --git a/Easy/Implement Stack using Queues.java b/Easy/Implement Stack using Queues.java
index 43c62339..d93ce3ae 100644
--- a/Easy/Implement Stack using Queues.java	
+++ b/Easy/Implement Stack using Queues.java	
@@ -1,52 +1,51 @@
 class MyStack {
-  
-  private Queue<Integer> primaryQueue;
-  private Queue<Integer> secondaryQueue;
-  
-  public MyStack() {
-    this.primaryQueue = new LinkedList<>();
-    this.secondaryQueue = new LinkedList<>();
-  }
+    
+    private final Queue<Integer> mainQueue;
+    private final Queue<Integer> backupQueue;
 
-  public void push(int x) {
-    this.primaryQueue.add(x);
-  }
-
-  public int pop() {
-    int result = moveFromPrimaryToSecondary();
-    moveFromSecondaryToPrimary(true);
-    return result;
-  }
-
-  public int top() {
-    int result = moveFromPrimaryToSecondary();
-    moveFromSecondaryToPrimary(false);
-    return result;
-  }
-  
-  public boolean empty() {
-    return this.primaryQueue.isEmpty();
-  }
-  
-  private int moveFromPrimaryToSecondary() {
-    int last = this.primaryQueue.peek();
-    while (!this.primaryQueue.isEmpty()) {
-      last = this.primaryQueue.peek();
-      this.secondaryQueue.add(this.primaryQueue.remove());
+    public MyStack() {
+        this.mainQueue = new LinkedList<>();
+        this.backupQueue = new LinkedList<>();
+    }
+    
+    public void push(int x) {
+        this.mainQueue.add(x);
+    }
+    
+    public int pop() {
+        int lastElement = moveToBackupQueue();
+        moveToMainQueue(true);
+        return lastElement;
+    }
+    
+    public int top() {
+        int lastElement = moveToBackupQueue();
+        moveToMainQueue(false);
+        return lastElement;
+    }
+    
+    public boolean empty() {
+        return this.mainQueue.isEmpty();
     }
-    return last;
-  }
-  
-  private void moveFromSecondaryToPrimary(boolean removeLast) {
-    while (this.secondaryQueue.size() > 1) {
-      this.primaryQueue.add(this.secondaryQueue.remove());
+    
+    private int moveToBackupQueue() {
+        int lastElement = this.mainQueue.peek();
+        while (!this.mainQueue.isEmpty()) {
+            lastElement = this.mainQueue.peek();
+            this.backupQueue.add(this.mainQueue.poll());
+        }
+        return lastElement;
     }
-    if (removeLast) {
-      this.secondaryQueue.remove();
-    } else {
-      this.primaryQueue.add(this.secondaryQueue.remove());
+    
+    private void moveToMainQueue(boolean removeLast) {
+        int sizeLimit = removeLast ? 1 : 0;
+        while (this.backupQueue.size() > sizeLimit) {
+            this.mainQueue.add(this.backupQueue.poll());
+        }
+        if (removeLast) {
+            this.backupQueue.remove();
+        }
     }
-  }
 }
 
 /**

From 455fcb85c8c55a2a90bc8bd9a2224cd5458f82a2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 27 Aug 2023 17:44:46 -0700
Subject: [PATCH 1777/2175] Update Implement Stack using Queues.java


From e361d66356431914ebfd507b9924188e1a7f2ffd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Aug 2023 08:58:42 -0700
Subject: [PATCH 1778/2175] Create Minimum Penalty for a Shop.java

---
 Medium/Minimum Penalty for a Shop.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Minimum Penalty for a Shop.java

diff --git a/Medium/Minimum Penalty for a Shop.java b/Medium/Minimum Penalty for a Shop.java
new file mode 100644
index 00000000..e5c5eaa9
--- /dev/null
+++ b/Medium/Minimum Penalty for a Shop.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int bestClosingTime(String customers) {
+        int n = customers.length();
+        int minPenalty = 0;
+        int currPenalty = 0;
+        int minPenaltyHour = 0;
+        for (int i = 0; i < n; i++) {
+            currPenalty += customers.charAt(i) == 'Y' ? -1 : 1;
+            if (currPenalty < minPenalty) {
+                minPenaltyHour = i + 1;
+                minPenalty = currPenalty;
+            }
+        }
+        return minPenaltyHour;
+    }
+}

From d9c6a40491a4fff7ce976d4252c0a15b30656e49 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 30 Aug 2023 08:02:04 -0700
Subject: [PATCH 1779/2175] Create Minimum Replacements to Sort the Array.java

---
 Hard/Minimum Replacements to Sort the Array.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Hard/Minimum Replacements to Sort the Array.java

diff --git a/Hard/Minimum Replacements to Sort the Array.java b/Hard/Minimum Replacements to Sort the Array.java
new file mode 100644
index 00000000..1c3cfc4f
--- /dev/null
+++ b/Hard/Minimum Replacements to Sort the Array.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public long minimumReplacement(int[] nums) {
+        int n = nums.length;
+        long numOfOperations = 0;
+        for (int i = n - 2; i >= 0; i--) {
+            if (nums[i] > nums[i + 1]) {
+                long numElements = (long)(nums[i] + nums[i + 1] - 1) / (long)nums[i + 1];
+                numOfOperations += numElements - 1;
+                nums[i] = nums[i] / (int)numElements;
+            }
+        }
+        return numOfOperations;
+    }
+}

From 66a79a031f220ba6f295a9db2bb69321aa76a9f9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 1 Sep 2023 09:53:25 -0700
Subject: [PATCH 1780/2175] Update Counting Bits.java

---
 Easy/Counting Bits.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Easy/Counting Bits.java b/Easy/Counting Bits.java
index 4d948810..4b5c69fa 100644
--- a/Easy/Counting Bits.java	
+++ b/Easy/Counting Bits.java	
@@ -1,9 +1,9 @@
 class Solution {
-  public int[] countBits(int n) {
-    int[] numofOnes = new int[n + 1];
-    for (int i = 1; i <= n; i++) {
-      numofOnes[i] = numofOnes[i / 2] + i % 2;
+    public int[] countBits(int n) {
+        int[] result = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            result[i] = result[i / 2] + i % 2;
+        }
+        return result;
     }
-    return numofOnes;
-  }
 }

From 475f7f8e8f7c252b2ee98098364ea672f1339071 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Sep 2023 14:58:05 -0700
Subject: [PATCH 1781/2175] Create Check if Strings Can be Made Equal With
 Operations I.java

---
 ...k if Strings Can be Made Equal With Operations I.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Check if Strings Can be Made Equal With Operations I.java

diff --git a/Easy/Check if Strings Can be Made Equal With Operations I.java b/Easy/Check if Strings Can be Made Equal With Operations I.java
new file mode 100644
index 00000000..cc99065a
--- /dev/null
+++ b/Easy/Check if Strings Can be Made Equal With Operations I.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public boolean canBeEqual(String s1, String s2) {
+        boolean firstSwap = (s1.charAt(0) == s2.charAt(0) && s1.charAt(2) == s2.charAt(2)) || 
+            (s1.charAt(2) == s2.charAt(0) && s1.charAt(0) == s2.charAt(2));
+        boolean secondSwap = (s1.charAt(1) == s2.charAt(1) && s1.charAt(3) == s2.charAt(3)) || 
+            (s1.charAt(1) == s2.charAt(3) && s1.charAt(3) == s2.charAt(1));
+        return firstSwap && secondSwap;
+    }
+}

From b850056ed748167424052d4655f24d9c9cb3687f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Sep 2023 15:21:15 -0700
Subject: [PATCH 1782/2175] Create Check if Strings Can be Made Equal With
 Operations II.java

---
 ... Can be Made Equal With Operations II.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Check if Strings Can be Made Equal With Operations II.java

diff --git a/Medium/Check if Strings Can be Made Equal With Operations II.java b/Medium/Check if Strings Can be Made Equal With Operations II.java
new file mode 100644
index 00000000..7507b140
--- /dev/null
+++ b/Medium/Check if Strings Can be Made Equal With Operations II.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public boolean checkStrings(String s1, String s2) {
+        int[] odd = new int[26];
+        int[] even = new int[26];
+        for (int i = 0; i < s1.length(); i++) {
+            if (i % 2 == 0) {
+                even[s1.charAt(i) - 'a']++;
+                even[s2.charAt(i) - 'a']--;
+            } else {
+                odd[s1.charAt(i) - 'a']++;
+                odd[s2.charAt(i) - 'a']--;
+            }
+        }
+        for (int i = 0; i < 26; i++) {
+            if (odd[i] != 0 || even[i] != 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From 4b0fa539231b11fde6b3aba232bb0d712252c20a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 5 Sep 2023 12:48:01 -0700
Subject: [PATCH 1783/2175] Create Count Symmetric Integers.java

---
 Easy/Count Symmetric Integers.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Count Symmetric Integers.java

diff --git a/Easy/Count Symmetric Integers.java b/Easy/Count Symmetric Integers.java
new file mode 100644
index 00000000..f32301e1
--- /dev/null
+++ b/Easy/Count Symmetric Integers.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int countSymmetricIntegers(int low, int high) {
+        int result = 0;
+        for (int i = low; i <= high; i++) {
+            String s = String.valueOf(i);
+            int diff = 0;
+            int n = s.length();
+            for (int j = 0; j < n / 2; j++) {
+                diff += s.charAt(j) - s.charAt(n - j - 1);
+            }
+            if (n % 2 == 0 && diff == 0) {
+                result++;
+            }
+        }
+        return result;
+    }
+}

From 5642e0cadbeeb10bcbaa534f2d74c7645915bb20 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Sep 2023 07:35:18 -0700
Subject: [PATCH 1784/2175] Update Split Linked List in Parts.java

---
 Medium/Split Linked List in Parts.java | 40 ++++++++++++++------------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/Medium/Split Linked List in Parts.java b/Medium/Split Linked List in Parts.java
index 30121c82..2fdd787c 100644
--- a/Medium/Split Linked List in Parts.java	
+++ b/Medium/Split Linked List in Parts.java	
@@ -7,25 +7,27 @@
  *     ListNode(int val) { this.val = val; }
  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
-*/
+ */
 class Solution {
-  public ListNode[] splitListToParts(ListNode head, int k) {
-    ListNode[] arr = new ListNode[k];
-    int nodeLength = 0;
-    for (ListNode curr = head; curr != null; curr = curr.next) {
-      nodeLength++;
+    public ListNode[] splitListToParts(ListNode head, int k) {
+        int length = 0;
+        ListNode curr = head;
+        while (curr != null) {
+            length++;
+            curr = curr.next;
+        }
+        ListNode[] splits = new ListNode[k];
+        int elementsPerPart = length / k;
+        int partsWithExtra = length % k;
+        ListNode prev = null;
+        for (int i = 0; i < k && head != null; i++, partsWithExtra--) {
+            splits[i] = head;
+            for (int j = 0; j < elementsPerPart + (partsWithExtra > 0 ? 1 : 0); j++) {
+                prev = head;
+                head = head.next;
+            }
+            prev.next = null;
+        }
+        return splits;
     }
-    int n = nodeLength / k;
-    int remaining = nodeLength % k;
-    ListNode prev = null;
-    for (int i = 0; i < k && head != null; i++, remaining--) {
-      arr[i] = head;
-      for (int j = 0; j < n + (remaining > 0 ? 1 : 0); j++) {
-        prev = head;
-        head = head.next;
-      }
-      prev.next = null;
-    }
-    return arr;
-  }
 }

From c9d4f1a65cbf4bdc3919d1040aa160247e806514 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Sep 2023 14:54:20 -0700
Subject: [PATCH 1785/2175] Create Minimum Operations to Make a Special
 Number.java

---
 ...m Operations to Make a Special Number.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Minimum Operations to Make a Special Number.java

diff --git a/Medium/Minimum Operations to Make a Special Number.java b/Medium/Minimum Operations to Make a Special Number.java
new file mode 100644
index 00000000..20f250fc
--- /dev/null
+++ b/Medium/Minimum Operations to Make a Special Number.java	
@@ -0,0 +1,25 @@
+class Solution {
+    
+    private final int NOT_FOUND_VALUE = 100_000;
+    
+    public int minimumOperations(String num) {
+        Integer[][] dp = new Integer[100][25];
+        return helper(num, 0, 0, dp);
+    }
+    
+    private int helper(String num, int idx, int mod, Integer[][] dp) {
+        if (idx == num.length()) {
+            if (mod == 0) {
+                return 0;
+            }
+            return NOT_FOUND_VALUE;
+        }
+        if (dp[idx][mod] != null) {
+            return dp[idx][mod];
+        }
+        int take = helper(num, idx + 1, (mod * 10 + (num.charAt(idx) - '0')) % 25, dp);
+        int remove = 1 + helper(num, idx + 1, mod, dp);
+        dp[idx][mod] = Math.min(take, remove);
+        return dp[idx][mod];
+    }
+}

From b234fe82a97a0e0eb0ac48c08e11ff4593befaf2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Sep 2023 17:16:17 -0700
Subject: [PATCH 1786/2175] Update Reverse Linked List II.java

---
 Medium/Reverse Linked List II.java | 72 +++++++++++++++---------------
 1 file changed, 37 insertions(+), 35 deletions(-)

diff --git a/Medium/Reverse Linked List II.java b/Medium/Reverse Linked List II.java
index 53edc4e4..3835dbcd 100644
--- a/Medium/Reverse Linked List II.java	
+++ b/Medium/Reverse Linked List II.java	
@@ -9,41 +9,43 @@
  * }
  */
 class Solution {
-  public ListNode reverseBetween(ListNode head, int left, int right) {
-    ListNode prev = null;
-    ListNode start = head;
-    for (int i = 1; i < left; i++) {
-      prev = start;
-      start = start.next;
+    public ListNode reverseBetween(ListNode head, int left, int right) {
+        ListNode curr = head;
+        ListNode prevToLeft = null;
+        for (int i = 1; i < left; i++) {
+            prevToLeft = curr;
+            curr = curr.next;
+        }
+        ListNode nextToLeft = prevToLeft == null ? head : prevToLeft.next;
+        for (int i = left; i < right; i++) {
+            curr = curr.next;
+        }
+        ListNode nextToRight = curr.next;
+        curr.next = null;
+        if (prevToLeft != null) {
+            prevToLeft.next = null;
+        }
+        ListNode reversedStart = reverse(nextToLeft);
+        if (prevToLeft != null) {
+            prevToLeft.next = reversedStart;
+        }
+        curr = reversedStart;
+        while (curr.next != null) {
+            curr = curr.next;
+        }
+        curr.next = nextToRight;
+        return prevToLeft == null ? reversedStart : head;
     }
-    ListNode end = start;
-    for (int i = left; i < right; i++) {
-      end = end.next;
+    
+    private ListNode reverse(ListNode head) {
+        ListNode prev = null;
+        ListNode curr = head;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
     }
-    ListNode nextToEnd = end.next;
-    end.next = null;
-    ListNode reverseStart = reverse(start);
-    if (prev != null) {
-      prev.next = reverseStart;
-    }
-    ListNode curr = reverseStart;
-    while (curr.next != null) {
-      curr = curr.next;
-    }
-    curr.next = nextToEnd;
-    return prev == null ? reverseStart : head;
-  }
-  
-  private ListNode reverse(ListNode node) {
-    ListNode prev = null;
-    ListNode next = null;
-    ListNode curr = node;
-    while (curr != null) {
-      next = curr.next;
-      curr.next = prev;
-      prev = curr;
-      curr = next;
-    }
-    return prev;
-  }
 }

From dadb59b7d7253a89f042fc39a3d9529fad48ccc5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Sep 2023 07:15:39 -0700
Subject: [PATCH 1787/2175] Create Maximum Sum of Almost Unique Subarray.java

---
 ...Maximum Sum of Almost Unique Subarray.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Maximum Sum of Almost Unique Subarray.java

diff --git a/Medium/Maximum Sum of Almost Unique Subarray.java b/Medium/Maximum Sum of Almost Unique Subarray.java
new file mode 100644
index 00000000..1d9facff
--- /dev/null
+++ b/Medium/Maximum Sum of Almost Unique Subarray.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public long maxSum(List<Integer> nums, int m, int k) {
+        long result = 0;
+        long currSum = 0;
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        int uniqueCount = 0;
+        for (int i = 0; i < nums.size(); i++) {
+            int curr = nums.get(i);
+            frequencyMap.put(curr, frequencyMap.getOrDefault(curr, 0) + 1);
+            if (frequencyMap.get(curr) == 1) {
+                uniqueCount++;
+            }
+            currSum += curr;
+            if (i >= k - 1) {
+                if (uniqueCount >= m) {
+                    result = Math.max(result, currSum);
+                }
+                int temp = nums.get(i - k + 1);
+                frequencyMap.put(temp, frequencyMap.getOrDefault(temp, 0) - 1);
+                if (frequencyMap.get(temp) == 0) {
+                    uniqueCount--;
+                }
+                currSum -= temp;
+            }
+        }
+        return result;
+    }
+}

From 1f561e474e24e63411218f05e4fdfc11e049434a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 8 Sep 2023 10:59:22 -0700
Subject: [PATCH 1788/2175] Create Rearrange String k Distance Apart.java

---
 Hard/Rearrange String k Distance Apart.java | 26 +++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Hard/Rearrange String k Distance Apart.java

diff --git a/Hard/Rearrange String k Distance Apart.java b/Hard/Rearrange String k Distance Apart.java
new file mode 100644
index 00000000..da212877
--- /dev/null
+++ b/Hard/Rearrange String k Distance Apart.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public String rearrangeString(String s, int k) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        PriorityQueue<Character> pq = new PriorityQueue<>((a, b) -> map.get(b).compareTo(map.get(a)));
+        Queue<Character> busy = new LinkedList<>();
+        StringBuilder sb = new StringBuilder();
+        pq.addAll(map.keySet());
+        while (!pq.isEmpty()) {
+            Character removed = pq.poll();
+            sb.append(removed);
+            map.put(removed, map.get(removed) - 1);
+            busy.add(removed);
+            if (busy.size() < k) {
+                continue;
+            }
+            Character busyRemoved = busy.remove();
+            if (map.get(busyRemoved) > 0) {
+                pq.add(busyRemoved);
+            }
+        }
+        return sb.length() == s.length() ? sb.toString() : "";
+    }
+}

From 42c41ac800637e833bbbf733b4b880fb1b5d806f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Sep 2023 07:44:36 -0700
Subject: [PATCH 1789/2175] Update Combination Sum IV.java

---
 Medium/Combination Sum IV.java | 39 ++++++++++++++++------------------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/Medium/Combination Sum IV.java b/Medium/Combination Sum IV.java
index bc8c1924..3a0eb51e 100644
--- a/Medium/Combination Sum IV.java	
+++ b/Medium/Combination Sum IV.java	
@@ -1,25 +1,22 @@
 class Solution {
-  public int combinationSum4(int[] nums, int target) {
-    Integer[] dp = new Integer[target + 1];
-    return getCount(target, nums, dp);
-  }
-  
-  public int getCount(int target, int[] nums, Integer[] dp) {
-    if (dp[target] != null) {
-      return dp[target];
+    public int combinationSum4(int[] nums, int target) {
+        Integer[] dp = new Integer[target + 1];
+        return helper(nums, target, dp);
     }
-    if (target == 0) {
-      return 1;
+
+    private int helper(int[] nums, int target, Integer[] dp) {
+        if (dp[target] != null) {
+            return dp[target];
+        }
+        if (target == 0) {
+            return 1;
+        }
+        int count = 0;
+        for (int num : nums) {
+            if (target >= num) {
+                count += helper(nums, target - num, dp);
+            }
+        }
+        return dp[target] = count;
     }
-    if (target < 0) {
-      return 0;
-    }
-    int total = 0;
-    for (int num : nums) {
-      if (target >= num) {
-        total += getCount(target - num, nums, dp);
-      }
-    }
-    return dp[target] = total;
-  }
 }

From 64429283f6c25e5d98d69cb7fc0aa0427004dc5c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Sep 2023 06:56:14 -0700
Subject: [PATCH 1790/2175] Update Group the People Given the Group Size They
 Belong To.java

---
 ...e Given the Group Size They Belong To.java | 30 +++++++++----------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/Medium/Group the People Given the Group Size They Belong To.java b/Medium/Group the People Given the Group Size They Belong To.java
index 475cf0c6..095fb67f 100644
--- a/Medium/Group the People Given the Group Size They Belong To.java	
+++ b/Medium/Group the People Given the Group Size They Belong To.java	
@@ -1,20 +1,18 @@
 class Solution {
-  public List<List<Integer>> groupThePeople(int[] groupSizes) {
-    Map<Integer, Queue<Integer>> groupSizeToId = new HashMap<>();
-    for (int i = 0; i < groupSizes.length; i++) {
-      groupSizeToId.computeIfAbsent(groupSizes[i], k -> new LinkedList<>()).add(i);
-    }
-    List<List<Integer>> result = new ArrayList<>();
-    for (Integer groupSize : groupSizeToId.keySet()) {
-      Queue<Integer> ids = groupSizeToId.get(groupSize);
-      while (!ids.isEmpty()) {
-        List<Integer> group = new ArrayList<>(groupSize);
-        for (int i = 0; i< groupSize; i++) {
-          group.add(ids.remove());
+    public List<List<Integer>> groupThePeople(int[] groupSizes) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int i = 0; i < groupSizes.length; i++) {
+            map.computeIfAbsent(groupSizes[i], k -> new ArrayList<>()).add(i);
+        }
+        List<List<Integer>> result = new ArrayList<>();
+        for (Integer key : map.keySet()) {
+            List<Integer> candidates = map.get(key);
+            int idx = 0;
+            while (idx < candidates.size()) {
+                result.add(candidates.subList(idx, idx + key));
+                idx += key;
+            }
         }
-        result.add(group);
-      }
+        return result;
     }
-    return result;
-  }
 }

From cbdf34baf52b2dae10108834af7ac3c63f24e3dc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Sep 2023 09:37:35 -0700
Subject: [PATCH 1791/2175] Create Points That Intersect With Cars.java

---
 Easy/Points That Intersect With Cars.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Points That Intersect With Cars.java

diff --git a/Easy/Points That Intersect With Cars.java b/Easy/Points That Intersect With Cars.java
new file mode 100644
index 00000000..8443505c
--- /dev/null
+++ b/Easy/Points That Intersect With Cars.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int numberOfPoints(List<List<Integer>> coordinates) {
+        coordinates.sort(Comparator.comparingInt((List<Integer> o) -> o.get(0)).thenComparingInt(o -> o.get(1)));
+        int points = 0;
+        int intervalStart = -1;
+        int intervalEnd = -1;
+        for (List<Integer> coordinate : coordinates) {
+            if (intervalStart == -1) {
+                intervalStart = coordinate.get(0);
+            } else {
+                if (intervalEnd < coordinate.get(0)) {
+                    points += intervalEnd - intervalStart + 1;
+                    intervalStart = coordinate.get(0);
+                }
+            }
+            intervalEnd = Math.max(intervalEnd, coordinate.get(1));
+        }
+        return points + intervalEnd - intervalStart + 1;
+    }
+}

From 65f9addfce377ab18e93c9d8c0b7f87f03b4e3e0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Sep 2023 15:43:54 -0700
Subject: [PATCH 1792/2175] Create Determine if a Cell Is Reachable at a Given
 Time.java

---
 ...termine if a Cell Is Reachable at a Given Time.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Medium/Determine if a Cell Is Reachable at a Given Time.java

diff --git a/Medium/Determine if a Cell Is Reachable at a Given Time.java b/Medium/Determine if a Cell Is Reachable at a Given Time.java
new file mode 100644
index 00000000..37878fa8
--- /dev/null
+++ b/Medium/Determine if a Cell Is Reachable at a Given Time.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean isReachableAtTime(int sx, int sy, int fx, int fy, int t) {
+        int xDiff = Math.abs(sx - fx);
+        int yDiff = Math.abs(sy - fy);
+        if (xDiff == 0 && yDiff == 0 && t == 1) {
+            return false;
+        }
+        return (Math.min(xDiff, yDiff) + Math.abs(xDiff - yDiff)) <= t; 
+    }
+}

From 01347e7f723f0c155ebfef1c2f7d18b5de7672a2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 12 Sep 2023 07:17:04 -0700
Subject: [PATCH 1793/2175] Update Minimum Deletions to Make Character
 Frequencies Unique.java

---
 ... to Make Character Frequencies Unique.java | 42 +++++++++----------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/Medium/Minimum Deletions to Make Character Frequencies Unique.java b/Medium/Minimum Deletions to Make Character Frequencies Unique.java
index f98fa559..2d57dc68 100644
--- a/Medium/Minimum Deletions to Make Character Frequencies Unique.java	
+++ b/Medium/Minimum Deletions to Make Character Frequencies Unique.java	
@@ -1,25 +1,25 @@
 class Solution {
-  public int minDeletions(String s) {
-    int[] frequency = new int[26];
-    for (char c : s.toCharArray()) {
-      frequency[c - 'a']++;
-    }
-    PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
-    for (int freq : frequency) {
-      if (freq > 0) {
-        pq.add(freq);
-      }
-    }
-    int numOfDeletions = 0;
-    while (!pq.isEmpty()) {
-      int removedFreq = pq.poll();
-      if (!pq.isEmpty() && pq.peek() == removedFreq) {
-        numOfDeletions++;
-        if (removedFreq > 1) {
-          pq.add(removedFreq - 1);
+    public int minDeletions(String s) {
+        int[] frequency = new int[26];
+        for (char c : s.toCharArray()) {
+            frequency[c - 'a']++;
+        }
+        Arrays.sort(frequency);
+        int numOfDeletions = 0;
+        int expectedFrequency = frequency[25];
+        for (int i = 25; i >= 0; i--) {
+            if (frequency[i] == 0) {
+                break;
+            }
+            if (frequency[i] > expectedFrequency) {
+                numOfDeletions += frequency[i] - expectedFrequency;
+            } else {
+                expectedFrequency = frequency[i];
+            }
+            if (expectedFrequency > 0) {
+                expectedFrequency--;
+            }
         }
-      }
+        return numOfDeletions;
     }
-    return numOfDeletions;
-  }
 }

From 9759e5a4ba6ea77fbfc3fb32cc8a0c65eba460ea Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Sep 2023 07:26:55 -0700
Subject: [PATCH 1794/2175] Update Candy.java

---
 Hard/Candy.java | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/Hard/Candy.java b/Hard/Candy.java
index 5bf67db1..269d4d6a 100644
--- a/Hard/Candy.java
+++ b/Hard/Candy.java
@@ -1,19 +1,22 @@
 class Solution {
-  public int candy(int[] ratings) {
-    int[] candies = new int[ratings.length];
-    Arrays.fill(candies, 1);
-    for (int i = 1; i < ratings.length; i++) {
-      if (ratings[i] > ratings[i - 1]) {
-        candies[i] = candies[i - 1] + 1;
-      }
+    public int candy(int[] ratings) {
+        int n = ratings.length;
+        int[] candies = new int[n];
+        Arrays.fill(candies, 1);
+        for (int i = 1; i < n; i++) {
+            if (ratings[i] > ratings[i - 1]) {
+                candies[i] = candies[i - 1] + 1;
+            }
+        }
+        for (int i = n - 2; i >= 0; i--) {
+            if (ratings[i] > ratings[i + 1]) {
+                candies[i] = Math.max(candies[i], candies[i + 1] + 1);
+            }
+        }
+        int totalCandies = 0;
+        for (int i = 0; i < n; i++) {
+            totalCandies += candies[i];
+        }
+        return totalCandies;
     }
-    int totalCandies = candies[candies.length - 1];
-    for (int i = ratings.length - 2; i >= 0; i--) {
-      if (ratings[i] > ratings[i + 1]) {
-        candies[i] = Math.max(candies[i], candies[i + 1] + 1);
-      }
-      totalCandies += candies[i];
-    }
-    return totalCandies;
-  }
 }

From 49a1a51566eb3eeb63ce779c6ddc869246a24e89 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Sep 2023 18:02:02 -0700
Subject: [PATCH 1795/2175] Update Reconstruct Itinerary.java

---
 Hard/Reconstruct Itinerary.java | 35 +++++++++++++++------------------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/Hard/Reconstruct Itinerary.java b/Hard/Reconstruct Itinerary.java
index 0c3c962f..e5616f94 100644
--- a/Hard/Reconstruct Itinerary.java	
+++ b/Hard/Reconstruct Itinerary.java	
@@ -1,22 +1,19 @@
 class Solution {
-  public List<String> findItinerary(List<List<String>> tickets) {
-    Map<String, PriorityQueue<String>> map = new HashMap<>();
-    for (List<String> ticket : tickets) {
-      String from = ticket.get(0);
-      String to = ticket.get(1);
-      map.computeIfAbsent(from, k -> new PriorityQueue<>()).add(to);
+    public List<String> findItinerary(List<List<String>> tickets) {
+        Map<String, PriorityQueue<String>> map = new HashMap<>();
+        for (List<String> ticket : tickets) {
+            map.computeIfAbsent(ticket.get(0), k -> new PriorityQueue<>()).add(ticket.get(1));
+        }
+        Stack<String> stack = new Stack<>();
+        stack.push("JFK");
+        List<String> result = new ArrayList<>();
+        while (!stack.isEmpty()) {
+            while (map.containsKey(stack.peek()) && !map.get(stack.peek()).isEmpty()) {
+                stack.push(map.get(stack.peek()).poll());
+            }
+            result.add(stack.pop());
+        }
+        Collections.reverse(result);
+        return result;
     }
-    Stack<String> stack = new Stack<>();
-    LinkedList<String> result = new LinkedList<>();
-    stack.push("JFK");
-    while (!stack.isEmpty()) {
-      String destination = stack.peek();
-      if (!map.getOrDefault(destination, new PriorityQueue<>()).isEmpty()) {
-        stack.push(map.get(destination).remove());
-      } else {
-        result.addFirst(stack.pop());
-      }
-    }
-    return result;
-  }
 }

From 76f32c6f4fd8eb4c621f18ae29c042ff7110ea77 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 15 Sep 2023 09:28:06 -0700
Subject: [PATCH 1796/2175] Update Min Cost to Connect All Points.java

---
 Medium/Min Cost to Connect All Points.java | 126 +++++++++------------
 1 file changed, 55 insertions(+), 71 deletions(-)

diff --git a/Medium/Min Cost to Connect All Points.java b/Medium/Min Cost to Connect All Points.java
index 15cc689b..168142ca 100644
--- a/Medium/Min Cost to Connect All Points.java	
+++ b/Medium/Min Cost to Connect All Points.java	
@@ -1,80 +1,64 @@
 class Solution {
-  public int minCostConnectPoints(int[][] points) {
-    int n = points.length;
-    PriorityQueue<Edge> priorityQueue = new PriorityQueue<>((x, y) -> x.cost - y.cost);
-    UnionFind unionFind = new UnionFind(n);
-    for (int i = 0; i < n; i++) {
-      int[] coordinate = points[i];
-      for (int j = i + 1; j < n; j++) {
-        int[] secondCoordinate = points[j];
-        int cost = Math.abs(coordinate[0] - secondCoordinate[0]) + Math.abs(coordinate[1] - secondCoordinate[1]);
-        Edge edge = new Edge(i, j, cost);
-        priorityQueue.add(edge);
-      }
-    }
-    int minimumCost = 0;
-    int totalEdges = n - 1;
-    while (!priorityQueue.isEmpty() && totalEdges > 0) {
-      Edge edge = priorityQueue.poll();
-      if (!unionFind.connected(edge.pointOne, edge.pointTwo)) {
-        unionFind.union(edge.pointOne, edge.pointTwo);
-        minimumCost += edge.cost;
-        totalEdges--;
-      }
-    }
-    return minimumCost;
-  }
-
-  private static class Edge {
-    int pointOne;
-    int pointTwo;
-    int cost;
-
-    public Edge(int pointOne, int pointTwo, int cost) {
-      this.pointOne = pointOne;
-      this.pointTwo = pointTwo;
-      this.cost = cost;
+    public int minCostConnectPoints(int[][] points) {
+        int n = points.length;
+        List<int[]> edges = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                int weight = Math.abs(points[i][0] - points[j][0]) + Math.abs(points[i][1] - points[j][1]);
+                int[] curr = {weight, i, j};
+                edges.add(curr);
+            }
+        }
+        Collections.sort(edges, Comparator.comparingInt(a -> a[0]));
+        UnionFind unionFind = new UnionFind(n);
+        int minCost = 0;
+        int edgeUsedCount = 0;
+        for (int i = 0; i < edges.size() && edgeUsedCount < n - 1; i++) {
+            int nodeOne = edges.get(i)[1];
+            int nodeTwo = edges.get(i)[2];
+            int weight = edges.get(i)[0];
+            if (unionFind.union(nodeOne, nodeTwo)) {
+                minCost += weight;
+                edgeUsedCount++;
+            }
+        }
+        return minCost;
     }
-  }
-
-  private static class UnionFind {
 
-    private final int[] root;
-    private final int[] rank;
+    private static class UnionFind {
+        private final int[] group;
+        private final int[] rank;
 
-    public UnionFind(int size) {
-      this.root = new int[size];
-      this.rank = new int[size];
-      for (int i = 0; i < size; i++) {
-        this.root[i] = i;
-        this.rank[i] = 1;
-      }
-    }
-
-    public void union(int nodeOne, int nodeTwo) {
-      int rootOne = find(nodeOne);
-      int rootTwo = find(nodeTwo);
-      if (rootOne != rootTwo) {
-        if (this.rank[rootOne] > this.rank[rootTwo]) {
-          this.root[rootTwo] = rootOne;
-        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
-          this.root[rootOne] = rootTwo;
-        } else {
-          this.root[rootTwo] = rootOne;
-          this.rank[rootOne]++;
+        public UnionFind(int n) {
+            this.group = new int[n];
+            this.rank = new int[n];
+            for (int i = 0; i < n; i++) {
+                this.group[i] = i;
+            }
         }
-      }
-    }
 
-    public int find(int node) {
-      if (node == root[node]) {
-        return node;
-      }
-      return root[node] = find(root[node]);
-    }
+        public int find(int node) {
+            if (group[node] != node) {
+                group[node] = find(group[node]);
+            }
+            return group[node];
+        }
 
-    public boolean connected(int nodeOne, int nodeTwo) {
-      return find(nodeOne) == find(nodeTwo);
+        public boolean union(int nodeOne, int nodeTwo) {
+            int groupOne = find(nodeOne);
+            int groupTwo = find(nodeTwo);
+            if (groupOne == groupTwo) {
+                return false;
+            }
+            if (rank[groupOne] > rank[groupTwo]) {
+                group[groupTwo] = groupOne;
+            } else if (rank[groupOne] < rank[groupTwo]) {
+                group[groupOne] = groupTwo;
+            } else {
+                group[groupOne] = groupTwo;
+                rank[groupTwo]++;
+            }
+            return true;
+        }
     }
-  }
 }

From 80259e4d2dae2210d70bb5e05797fe6387ff5abd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 16 Sep 2023 16:23:50 -0700
Subject: [PATCH 1797/2175] Create Minimum Right Shifts to Sort the Array.java

---
 ...inimum Right Shifts to Sort the Array.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Minimum Right Shifts to Sort the Array.java

diff --git a/Easy/Minimum Right Shifts to Sort the Array.java b/Easy/Minimum Right Shifts to Sort the Array.java
new file mode 100644
index 00000000..aad801a0
--- /dev/null
+++ b/Easy/Minimum Right Shifts to Sort the Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int minimumRightShifts(List<Integer> nums) {
+        int mismatchIdx = -1;
+        int count = 0;
+        for (int i = 1; i < nums.size(); i++) {
+            if (nums.get(i - 1) > nums.get(i)) {
+                mismatchIdx = i;
+                count++;
+            }
+        }
+        if (count > 1) {
+            return -1;
+        }
+        if (count == 0) {
+            return 0;
+        }
+        return nums.get(nums.size() - 1) > nums.get(0) ? -1 : nums.size() - mismatchIdx;
+    }
+}

From c21dafb087383fafc50a347daf81d32b80ab826c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Sep 2023 09:34:14 -0700
Subject: [PATCH 1798/2175] Create Sum of Values at Indices With K Set
 Bits.java

---
 Easy/Sum of Values at Indices With K Set Bits.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Sum of Values at Indices With K Set Bits.java

diff --git a/Easy/Sum of Values at Indices With K Set Bits.java b/Easy/Sum of Values at Indices With K Set Bits.java
new file mode 100644
index 00000000..598f65c1
--- /dev/null
+++ b/Easy/Sum of Values at Indices With K Set Bits.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int sumIndicesWithKSetBits(List<Integer> nums, int k) {
+        return IntStream.range(0, nums.size())
+            .filter(idx -> Integer.bitCount(idx) == k)
+            .map(idx -> nums.get(idx))
+            .sum();
+    }
+}

From b07d068d74e02b8000bf3e7e475493845434524c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Sep 2023 12:05:05 -0700
Subject: [PATCH 1799/2175] Create Shortest Path Visiting All Nodes.java

---
 Hard/Shortest Path Visiting All Nodes.java | 33 ++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 Hard/Shortest Path Visiting All Nodes.java

diff --git a/Hard/Shortest Path Visiting All Nodes.java b/Hard/Shortest Path Visiting All Nodes.java
new file mode 100644
index 00000000..8d08ecfa
--- /dev/null
+++ b/Hard/Shortest Path Visiting All Nodes.java	
@@ -0,0 +1,33 @@
+class Solution {
+    public int shortestPathLength(int[][] graph) {
+        int n = graph.length;
+        Map<Integer, Set<Set<Integer>>> map = new HashMap<>();
+        Queue<State> queue = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            Set<Integer> visited = new HashSet<>();
+            visited.add(i);
+            map.put(i, new HashSet<>(List.of(visited)));
+            queue.add(new State(i, 0, visited));
+        }
+        while (!queue.isEmpty()) {
+            State removed = queue.remove();
+            int node = removed.node();
+            int steps = removed.steps();
+            Set<Integer> visited = removed.visited();
+            if (visited.size() == n) {
+                return steps;
+            }
+            for (int conn : graph[node]) {
+                Set<Integer> connVisited = new HashSet<>(visited);
+                connVisited.add(conn);
+                if (!map.get(conn).contains(connVisited)) {
+                    queue.add(new State(conn, steps + 1, connVisited));
+                    map.computeIfAbsent(conn, k -> new HashSet<>()).add(connVisited);
+                }
+            }
+        }
+        return -1;
+    }
+
+    private static record State(int node, int steps, Set<Integer> visited) {}
+}

From 5502fe64029d14cef414b388c85e8b2ba19f4de9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 18 Sep 2023 07:05:13 -0700
Subject: [PATCH 1800/2175] Update The K Weakest Rows in a Matrix.java

---
 Easy/The K Weakest Rows in a Matrix.java | 46 ++++++++++++------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/Easy/The K Weakest Rows in a Matrix.java b/Easy/The K Weakest Rows in a Matrix.java
index 09e395be..a4a52ad7 100644
--- a/Easy/The K Weakest Rows in a Matrix.java	
+++ b/Easy/The K Weakest Rows in a Matrix.java	
@@ -1,28 +1,28 @@
 class Solution {
-  public int[] kWeakestRows(int[][] mat, int k) {
-    PriorityQueue<int[]> pq = new PriorityQueue<>(
-        Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[0]));
-    for (int i = 0; i < mat.length; i++) {
-      pq.add(new int[]{i, getNumberOfOnes(mat[i])});
+    public int[] kWeakestRows(int[][] mat, int k) {
+        PriorityQueue<int[]> pq =
+                new PriorityQueue<>(Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[0]));
+        for (int i = 0; i < mat.length; i++) {
+            pq.add(new int[]{i, findNumberOfSoldiers(mat[i])});
+        }
+        int[] result = new int[k];
+        for (int i = 0; i < k && !pq.isEmpty(); i++){
+            result[i] = pq.poll()[0];
+        }
+        return result;
     }
-    int[] result = new int[k];
-    for (int i = 0; i < result.length && !pq.isEmpty(); i++) {
-      result[i] = pq.poll()[0];
-    }
-    return result;
-  }
 
-  private int getNumberOfOnes(int[] arr) {
-    int start = 0;
-    int end = arr.length - 1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (arr[mid] == 0) {
-        end = mid - 1;
-      } else {
-        start = mid + 1;
-      }
+    private int findNumberOfSoldiers(int[] row) {
+        int left = 0;
+        int right = row.length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (row[mid] == 0) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return right < 0 ? 0 : left;
     }
-    return end < 0 ? 0 : start;
-  }
 }

From 40bb0b180ad7865e54efd790f7f143131d723d41 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 18 Sep 2023 08:51:40 -0700
Subject: [PATCH 1801/2175] Update Parallel Courses.java

---
 Medium/Parallel Courses.java | 60 +++++++++++++++++++-----------------
 1 file changed, 31 insertions(+), 29 deletions(-)

diff --git a/Medium/Parallel Courses.java b/Medium/Parallel Courses.java
index a3843f23..797e3b58 100644
--- a/Medium/Parallel Courses.java	
+++ b/Medium/Parallel Courses.java	
@@ -1,33 +1,35 @@
 class Solution {
-  public int minimumSemesters(int n, int[][] relations) {
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    int[] indegree = new int[n + 1];
-    for (int[] relation : relations) {
-      graph.computeIfAbsent(relation[0], k -> new ArrayList<>()).add(relation[1]);
-      indegree[relation[1]]++;
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    int numOfSemesters = 0;
-    Set<Integer> coursesTaken = new HashSet<>();
-    for (int i = 1; i <= n; i++) {
-      if (indegree[i] == 0) {
-        queue.add(i);
-      }
-    }
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int course = queue.remove();
-        coursesTaken.add(course);
-        for (int dependentCourse : graph.getOrDefault(course, new ArrayList<>())) {
-          indegree[dependentCourse]--;
-          if (indegree[dependentCourse] <= 0 && !coursesTaken.contains(dependentCourse)) {
-            queue.add(dependentCourse);
-          }
+    public int minimumSemesters(int n, int[][] relations) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        int[] indegree = new int[n];
+        for (int[] relation : relations) {
+            int course = relation[0];
+            int dependency = relation[1];
+            indegree[course - 1]++;
+            graph.computeIfAbsent(dependency, k -> new HashSet<>()).add(course);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int numOfSemesters = 0;
+        int coursesTaken = 0;
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i + 1);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                coursesTaken++;
+                for (Integer dependent : graph.getOrDefault(removed, new HashSet<>())) {
+                    indegree[dependent - 1]--;
+                    if (indegree[dependent - 1] == 0) {
+                        queue.add(dependent);
+                    }
+                }
+            }
+            numOfSemesters++;
         }
-      }
-      numOfSemesters++;
+        return coursesTaken == n ? numOfSemesters : -1;
     }
-    return coursesTaken.size() == n ? numOfSemesters : -1;
-  }
 }

From 01039f5e50509d0fd496abadb507b3ae53b57cb2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 19 Sep 2023 08:19:22 -0700
Subject: [PATCH 1802/2175] Update Find the Duplicate Number.java


From b43550af66a9288fe7487d71cb1a95d81b8344c9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 19 Sep 2023 08:19:33 -0700
Subject: [PATCH 1803/2175] Update Find the Duplicate Number.java

---
 Medium/Find the Duplicate Number.java | 30 +++++++++++++++------------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/Medium/Find the Duplicate Number.java b/Medium/Find the Duplicate Number.java
index c4f5a541..bfd8908b 100644
--- a/Medium/Find the Duplicate Number.java	
+++ b/Medium/Find the Duplicate Number.java	
@@ -1,16 +1,20 @@
 class Solution {
-  public int findDuplicate(int[] nums) {
-    int slow = nums[0];
-    int fast = nums[0];
-    do {
-      slow = nums[slow];
-      fast = nums[nums[fast]];
-    } while (slow != fast);
-    slow = nums[0];
-    while (slow != fast) {
-      slow = nums[slow];
-      fast = nums[fast];
+    public int findDuplicate(int[] nums) {
+        int slow = nums[0];
+        int fast = nums[0];
+        while (true) {
+            slow = nums[slow];
+            fast = nums[nums[fast]];
+            if (slow == fast) {
+                break;
+            }
+        }
+        int idxOne = nums[0];
+        int idxTwo = slow;
+        while (idxOne != idxTwo) {
+            idxOne = nums[idxOne];
+            idxTwo = nums[idxTwo];
+        }
+        return idxOne;
     }
-    return fast;
-  }
 }

From 9f154a1703d583d7261bda066aa242e92cdba3f3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Sep 2023 08:30:12 -0700
Subject: [PATCH 1804/2175] Update Minimum Operations to Reduce X to Zero.java

---
 ...inimum Operations to Reduce X to Zero.java | 37 ++++++++++---------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/Medium/Minimum Operations to Reduce X to Zero.java b/Medium/Minimum Operations to Reduce X to Zero.java
index 3e202cb6..f2f2a99b 100644
--- a/Medium/Minimum Operations to Reduce X to Zero.java	
+++ b/Medium/Minimum Operations to Reduce X to Zero.java	
@@ -1,21 +1,22 @@
 class Solution {
-  public int minOperations(int[] nums, int x) {
-    int totalSum = 0;
-    for (int num : nums) {
-      totalSum += num;
+    public int minOperations(int[] nums, int x) {
+        int sum = 0;
+        for (int num : nums) {
+            sum += num;
+        }
+        int max = -1;
+        int left = 0;
+        int curr = 0;
+        int n = nums.length;
+        for (int right = 0; right < n; right++) {
+            curr += nums[right];
+            while (curr > sum - x && left <= right) {
+                curr -= nums[left++];
+            }
+            if (curr == sum - x) {
+                max = Math.max(max, right - left + 1);
+            }
+        }
+        return max != -1 ? n - max : -1;
     }
-    int max = -1;
-    int left = 0;
-    int current = 0;
-    for (int right = 0; right < nums.length; right++) {
-      current += nums[right];
-      while (current > totalSum - x && left <= right) {
-        current -= nums[left++];
-      }
-      if (current == totalSum - x) {
-        max = Math.max(max, right - left + 1);
-      }
-    }
-    return max != -1 ? nums.length - max : -1;
-  }
 }

From e2c2b2372b952c4ee16f19250a05a4a7346defb4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 21 Sep 2023 17:20:10 -0700
Subject: [PATCH 1805/2175] Update Is Subsequence.java

---
 Easy/Is Subsequence.java | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/Easy/Is Subsequence.java b/Easy/Is Subsequence.java
index 90732379..2d67a698 100644
--- a/Easy/Is Subsequence.java	
+++ b/Easy/Is Subsequence.java	
@@ -1,11 +1,13 @@
 class Solution {
-  public boolean isSubsequence(String s, String t) {
-    int j = 0;
-    for (int i = 0; i < t.length() && j < s.length(); i++) {
-      if (s.charAt(j) == t.charAt(i)) {
-        j++;
-      }
+    public boolean isSubsequence(String s, String t) {
+        int sIdx = 0;
+        int tIdx = 0;
+        while (sIdx < s.length() && tIdx < t.length()) {
+            if (s.charAt(sIdx) == t.charAt(tIdx)) {
+                sIdx++;
+            }
+            tIdx++;
+        }
+        return sIdx == s.length();
     }
-    return j == s.length();
-  }
 }

From 162a26bf7f655add678c07960c5aa13ae9f02042 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Sep 2023 08:43:44 -0700
Subject: [PATCH 1806/2175] Update Longest String Chain.java

---
 Medium/Longest String Chain.java | 52 +++++++++++++++++---------------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/Medium/Longest String Chain.java b/Medium/Longest String Chain.java
index 17d14f0c..5c36ef9d 100644
--- a/Medium/Longest String Chain.java	
+++ b/Medium/Longest String Chain.java	
@@ -1,29 +1,31 @@
 class Solution {
-  public int longestStrChain(String[] words) {
-    Map<String, Integer> dp = new HashMap<>();
-    Set<String> wordSet = Arrays.stream(words).collect(Collectors.toSet());
-    int maxLength = 0;
-    for (String word : words) {
-      maxLength = Math.max(maxLength, dfs(wordSet, dp, word));
+    public int longestStrChain(String[] words) {
+        Set<String> wordSet = Arrays.stream(words)
+        .collect(Collectors.toSet());
+        Map<String, Integer> memo = new HashMap<>();
+        int result = 0;
+        for (String word : words) {
+            result = Math.max(result, dfs(wordSet, memo, word));
+        }
+        return result;
     }
-    return maxLength;
-  }
-  
-  private int dfs(Set<String> wordSet, Map<String, Integer> dp, String currWord) {
-    if (dp.containsKey(currWord)) {
-      return dp.get(currWord);
+
+    private int dfs(Set<String> wordSet, Map<String, Integer> memo, String word) {
+        if (memo.containsKey(word)) {
+            return memo.get(word);
+        }
+        int maxLength = 1;
+        StringBuilder sb = new StringBuilder(word);
+        for (int i = 0; i < word.length(); i++) {
+            sb.deleteCharAt(i);
+            String newWord = sb.toString();
+            if (wordSet.contains(newWord)) {
+                int currLength = 1 + dfs(wordSet, memo, newWord);
+                maxLength = Math.max(maxLength, currLength);
+            }
+            sb.insert(i, word.charAt(i));
+        }
+        memo.put(word, maxLength);
+        return maxLength;
     }
-    int maxLength = 1;
-    StringBuilder sb = new StringBuilder(currWord);
-    for (int i = 0; i < currWord.length(); i++) {
-      sb.deleteCharAt(i);
-      String newWord = sb.toString();
-      if (wordSet.contains(newWord)) {
-        maxLength = Math.max(maxLength, 1 + dfs(wordSet, dp, newWord));
-      }
-      sb.insert(i, currWord.charAt(i));
-    }
-    dp.put(currWord, maxLength);
-    return dp.get(currWord);
-  }
 }

From 5c7f8b7106ab6174d147f94899798faa047ac10f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Sep 2023 17:54:15 -0700
Subject: [PATCH 1807/2175] Update Champagne Tower.java

---
 Medium/Champagne Tower.java | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/Medium/Champagne Tower.java b/Medium/Champagne Tower.java
index b8f0797e..ccd07a8b 100644
--- a/Medium/Champagne Tower.java	
+++ b/Medium/Champagne Tower.java	
@@ -1,14 +1,13 @@
 class Solution {
-  public double champagneTower(int poured, int query_row, int query_glass) {
-    double[][] glassCapacity = new double[query_row + 1][query_glass + 2];
-    glassCapacity[0][0] = poured;
-    for (int currRow = 0; currRow < query_row; currRow++) {
-      for (int currCol = 0; currCol <= query_glass; currCol++) {
-        double currCapacity = Math.max(glassCapacity[currRow][currCol] - 1.0, 0);
-        glassCapacity[currRow + 1][currCol] += currCapacity / 2.0;
-        glassCapacity[currRow + 1][currCol + 1] += currCapacity / 2.0;
-      }
+    public double champagneTower(int poured, int query_row, int query_glass) {
+        double[] glass = new double[query_row + 2];
+        glass[0] = poured;
+        for (int row = 1; row <= query_row; row++) {
+            for (int idx = row; idx >= 0; idx--) {
+                glass[idx] = Math.max(0.0, (glass[idx] - 1) / 2);
+                glass[idx + 1] += glass[idx];
+            }
+        }
+        return Math.min(glass[query_glass], 1.0);
     }
-    return Math.min(glassCapacity[query_row][query_glass], 1.0);
-  } 
 }

From de2351a228b16cc5caf781bacccdee9e1224c0ae Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 24 Sep 2023 07:45:44 -0700
Subject: [PATCH 1808/2175] Create Maximum Odd Binary Number.java

---
 Easy/Maximum Odd Binary Number.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Maximum Odd Binary Number.java

diff --git a/Easy/Maximum Odd Binary Number.java b/Easy/Maximum Odd Binary Number.java
new file mode 100644
index 00000000..861a3fd1
--- /dev/null
+++ b/Easy/Maximum Odd Binary Number.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public String maximumOddBinaryNumber(String s) {
+        int oneCount = 0;
+        for (char c : s.toCharArray()) {
+            oneCount += c == '1' ? 1 : 0;
+        }
+        if (oneCount == 0) {
+            return s;
+        }
+        int zeroCount = s.length() - oneCount;
+        return "1".repeat(oneCount - 1) + "0".repeat(zeroCount) + "1";
+    }
+}

From f01834c0c536c2ed9f260a70376f117130f3629a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 24 Sep 2023 20:50:12 -0700
Subject: [PATCH 1809/2175] Update Find the difference.java

---
 Easy/Find the difference.java | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Easy/Find the difference.java b/Easy/Find the difference.java
index 710a70d3..ca12be6d 100644
--- a/Easy/Find the difference.java	
+++ b/Easy/Find the difference.java	
@@ -1,15 +1,15 @@
 class Solution {
-  public char findTheDifference(String s, String t) {
-    int[] counter = new int[26];
-    for (char c : s.toCharArray()) {
-      counter[c - 'a']++;
+    public char findTheDifference(String s, String t) {
+        int[] frequency = new int[26];
+        for (char c : s.toCharArray()) {
+            frequency[c - 'a']++;
+        }
+        for (char c : t.toCharArray()) {
+            if (frequency[c - 'a'] == 0) {
+                return c;
+            }
+            frequency[c - 'a']--;
+        }
+        return ' ';
     }
-    for (char c : t.toCharArray()) {
-      if (counter[c - 'a'] == 0) {
-        return c;
-      }
-      counter[c - 'a']--;
-    }
-    return '-';
-  }
 }

From f65450e5cc65333d00b56d73e1d3c7bd16eda4e3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Sep 2023 06:26:42 -0700
Subject: [PATCH 1810/2175] Update Remove Duplicate Letters.java

---
 Medium/Remove Duplicate Letters.java | 46 +++++++++++++---------------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/Medium/Remove Duplicate Letters.java b/Medium/Remove Duplicate Letters.java
index 25cfd16c..19bd928d 100644
--- a/Medium/Remove Duplicate Letters.java	
+++ b/Medium/Remove Duplicate Letters.java	
@@ -1,27 +1,25 @@
 class Solution {
-  public String removeDuplicateLetters(String s) {
-    int[] counter = new int[26];
-    for (char c : s.toCharArray()) {
-      counter[c - 'a']++;
+    public String removeDuplicateLetters(String s) {
+        Map<Character, Integer> lastIndexMap = new HashMap<>();
+        for (int i = 0; i < s.length(); i++) {
+            lastIndexMap.put(s.charAt(i), i);
+        }
+        Stack<Character> stack = new Stack<>();
+        Set<Character> visited = new HashSet<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (!visited.contains(c)) {
+                while (!stack.isEmpty() && c < stack.peek() && lastIndexMap.get(stack.peek()) > i) {
+                    visited.remove(stack.pop());
+                }
+                visited.add(c);
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (Character c : stack) {
+            sb.append(c);
+        }
+        return sb.toString();
     }
-    Stack<Integer> stack = new Stack<>();
-    boolean[] visited = new boolean[26];
-    for (char c : s.toCharArray()) {
-      int idx = c - 'a';
-      counter[idx]--;
-      if (visited[idx]) {
-        continue;
-      }
-      while (!stack.isEmpty() && stack.peek() > idx && counter[stack.peek()] > 0) {
-        visited[stack.pop()] = false;
-      }
-      stack.add(idx);
-      visited[idx] = true;
-    }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append((char) (stack.pop() + 'a'));
-    }
-    return sb.reverse().toString();
-  }
 }

From c0bc4aba017f8c62ec662106636418447fb40d88 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 27 Sep 2023 08:34:44 -0700
Subject: [PATCH 1811/2175] Create Decoded String at Index.java

---
 Medium/Decoded String at Index.java | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Decoded String at Index.java

diff --git a/Medium/Decoded String at Index.java b/Medium/Decoded String at Index.java
new file mode 100644
index 00000000..a0c94968
--- /dev/null
+++ b/Medium/Decoded String at Index.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public String decodeAtIndex(String s, int k) {
+        long size = 0;
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            if (Character.isDigit(c)) {
+                size *= (c - '0');
+            } else {
+                size++;
+            }
+        }
+        for (int i = n - 1; i >= 0; i--) {
+            char c = s.charAt(i);
+            k %= size;
+            if (k == 0 && Character.isLetter(c)) {
+                return Character.toString(c);
+            }
+            if (Character.isDigit(c)) {
+                size /= (c - '0');
+            } else {
+                size--;
+            }
+        }
+        return "";
+    }
+}

From 866f09583d07f33f6d988fa1df33fd98e3082923 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Sep 2023 09:02:43 -0700
Subject: [PATCH 1812/2175] Update Sort Array By Parity.java

---
 Easy/Sort Array By Parity.java | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/Easy/Sort Array By Parity.java b/Easy/Sort Array By Parity.java
index c74dcae0..0b54ae53 100644
--- a/Easy/Sort Array By Parity.java	
+++ b/Easy/Sort Array By Parity.java	
@@ -1,17 +1,16 @@
 class Solution {
-  public int[] sortArrayByParity(int[] A) {
-    int evenIdx = 0;
-    int oddIdx = A.length - 1;
-    while (evenIdx < oddIdx) {
-      if (A[evenIdx] % 2 == 0) {
-        evenIdx++;
-      } 
-      else {
-        int temp = A[evenIdx];
-        A[evenIdx] = A[oddIdx];
-        A[oddIdx--] = temp;
-      }
+    public int[] sortArrayByParity(int[] nums) {
+        int start = 0;
+        int end = 0;
+        int n = nums.length;
+        while (end < n) {
+            if (nums[end] % 2 == 0) {
+                int temp = nums[start];
+                nums[start++] = nums[end];
+                nums[end] = temp;
+            }
+            end++;
+        }
+        return nums;
     }
-    return A;
-  }
 }

From 0cb7779f1f326f3fdeb43c95db4b4c3620ad5b8d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Sep 2023 17:04:44 -0700
Subject: [PATCH 1813/2175] Update Monotonic Array.java

---
 Easy/Monotonic Array.java | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/Easy/Monotonic Array.java b/Easy/Monotonic Array.java
index 4a348d71..e460648c 100644
--- a/Easy/Monotonic Array.java	
+++ b/Easy/Monotonic Array.java	
@@ -1,21 +1,19 @@
 class Solution {
-  public boolean isMonotonic(int[] nums) {
-    int idx = 0;
-    int sign = 0;
-    while (idx < nums.length - 1 && sign == 0) {
-      if (nums[idx] < nums[idx + 1]) {
-        sign = 1;
-      } else if (nums[idx] > nums[idx + 1]) {
-        sign = -1;
-      }
-      idx++;
+    public boolean isMonotonic(int[] nums) {
+        int idx = 0;
+        while (idx + 1 < nums.length && nums[idx] == nums[idx + 1]) {
+            idx++;
+        } 
+        boolean increasing = idx + 1 < nums.length && nums[idx] < nums[idx + 1];
+        while (idx + 1 < nums.length) {
+            if (nums[idx] > nums[idx + 1] && increasing) {
+                return false;
+            }
+            if (nums[idx] < nums[idx + 1] && !increasing) {
+                return false;
+            }
+            idx++;
+        }
+        return true;
     }
-    while (idx < nums.length - 1) {
-      if ((sign == 1 && nums[idx] > nums[idx + 1]) || (sign == -1 && nums[idx] < nums[idx + 1])) {
-        return false;
-      }
-      idx++;
-    }
-    return true;
-  }
 }

From 88f4c846c5f3afca739cb44f3c2143963e783507 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Sep 2023 09:01:31 -0700
Subject: [PATCH 1814/2175] Update 132 Pattern.java

---
 Medium/132 Pattern.java | 38 ++++++++++++++++++--------------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/Medium/132 Pattern.java b/Medium/132 Pattern.java
index 80a6c64e..54937149 100644
--- a/Medium/132 Pattern.java	
+++ b/Medium/132 Pattern.java	
@@ -1,25 +1,23 @@
 class Solution {
-  public boolean find132pattern(int[] nums) {
-    if (nums.length < 3) {
-      return false;
-    }
-    int[] minTillIndex = new int[nums.length];
-    minTillIndex[0] = nums[0];
-    for (int idx = 1; idx < nums.length; idx++) {
-      minTillIndex[idx] = Math.min(minTillIndex[idx - 1], nums[idx]);
-    }
-    Stack<Integer> stack = new Stack<>();
-    for (int idx = nums.length - 1; idx >= 0; idx--) {
-      if (nums[idx] > minTillIndex[idx]) {
-        while (!stack.isEmpty() && stack.peek() <= minTillIndex[idx]) {
-          stack.pop();
+    public boolean find132pattern(int[] nums) {
+        int n = nums.length;
+        int[] uptoIdxMin = new int[n];
+        uptoIdxMin[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            uptoIdxMin[i] = Math.min(uptoIdxMin[i - 1], nums[i]);
         }
-        if (!stack.isEmpty() && stack.peek() < nums[idx]) {
-          return true;
+        Stack<Integer> stack = new Stack<>();
+        for (int i = n - 1; i >= 0; i--) {
+            if (nums[i] > uptoIdxMin[i]) {
+                while (!stack.isEmpty() && stack.peek() <= uptoIdxMin[i]) {
+                    stack.pop();
+                }
+                if (!stack.isEmpty() && stack.peek() < nums[i]) {
+                    return true;
+                }
+                stack.push(nums[i]);
+            }
         }
-        stack.push(nums[idx]);
-      }
+        return false;
     }
-    return false;
-  }
 }

From d202d37900aeec8a517f39041fa71efb7f53ba3a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Sep 2023 12:44:55 -0700
Subject: [PATCH 1815/2175] Create Minimum Operations to Collect Elements.java

---
 Easy/Minimum Operations to Collect Elements.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Minimum Operations to Collect Elements.java

diff --git a/Easy/Minimum Operations to Collect Elements.java b/Easy/Minimum Operations to Collect Elements.java
new file mode 100644
index 00000000..59e9d7c4
--- /dev/null
+++ b/Easy/Minimum Operations to Collect Elements.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int minOperations(List<Integer> nums, int k) {
+        boolean[] found = new boolean[k];
+        int foundCount = 0;
+        for (int i = nums.size() - 1; i >= 0; i--) {
+            if (nums.get(i) <= k && !found[nums.get(i) - 1]) {
+                found[nums.get(i) - 1] = true;
+                foundCount++;
+            }
+            if (foundCount == k) {
+                return nums.size() - i;
+            }
+        }
+        return -1;
+    }
+}

From f626d03defca6cbac2a486d21015785af18f5a99 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Sep 2023 18:26:02 -0700
Subject: [PATCH 1816/2175] Update Reverse words in a String III.java

---
 Easy/Reverse words in a String III.java | 47 ++++++++++++++-----------
 1 file changed, 27 insertions(+), 20 deletions(-)

diff --git a/Easy/Reverse words in a String III.java b/Easy/Reverse words in a String III.java
index e50dd770..c6c46160 100644
--- a/Easy/Reverse words in a String III.java	
+++ b/Easy/Reverse words in a String III.java	
@@ -1,23 +1,30 @@
 class Solution {
-  public String reverseWords(String s) {
-    int idx = 0;
-    int n = s.length();
-    StringBuilder sb = new StringBuilder();
-    int start = 0;
-    while (idx < n) {
-      while (idx < n && s.charAt(idx) != ' ') {
-        idx++;
-      }
-      int curr = idx - 1;
-      while (curr >= start) {
-        sb.append(s.charAt(curr--));
-      }
-      if (idx != n) {
-        sb.append(" ");
-      }
-      idx++;
-      start = idx;
+    public String reverseWords(String s) {
+        int start = 0;
+        int end = 0;
+        char[] chars = s.toCharArray();
+        while (end < s.length()) {
+            if (chars[end] == ' ') {
+                if (start < end - 1) {
+                    reverse(chars, start, end - 1);
+                }
+                end++;
+                start = end;
+            } else {
+                end++;
+            }
+        }
+        if (start < end) {
+            reverse(chars, start, end - 1);
+        }
+        return String.valueOf(chars);
+    }
+
+    private void reverse(char[] chars, int start, int end) {
+        while (start < end) {
+            char temp = chars[start];
+            chars[start++] = chars[end];
+            chars[end--] = temp;
+        }
     }
-    return sb.toString();
-  }
 }

From ea1ff399c56360f66ad2fe864017020756c9f811 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 1 Oct 2023 07:25:01 -0700
Subject: [PATCH 1817/2175] Create Maximum Value of an Ordered Triplet I.java

---
 ...Maximum Value of an Ordered Triplet I.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Maximum Value of an Ordered Triplet I.java

diff --git a/Easy/Maximum Value of an Ordered Triplet I.java b/Easy/Maximum Value of an Ordered Triplet I.java
new file mode 100644
index 00000000..870e4602
--- /dev/null
+++ b/Easy/Maximum Value of an Ordered Triplet I.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public long maximumTripletValue(int[] nums) {
+        int n = nums.length;
+        int[] maxLeft = new int[n];
+        int[] maxRight = new int[n];
+        maxLeft[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            maxLeft[i] = Math.max(maxLeft[i - 1], nums[i]);
+        }
+        maxRight[n - 1] = nums[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            maxRight[i] = Math.max(maxRight[i + 1], nums[i]);
+        }
+        long maxValue = -1;
+        for (int i = 1; i < n - 1; i++) {
+            long left = (long) maxLeft[i - 1];
+            long right = (long) maxRight[i + 1];
+            maxValue = Math.max(maxValue, (left - nums[i]) * right);
+        }
+        return maxValue == -1 ? 0 : maxValue;
+    }
+}

From ea6f89d24079ec634b9d51b8fdc2b82610d73217 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 1 Oct 2023 08:35:23 -0700
Subject: [PATCH 1818/2175] Update Implement Trie II (Prefix Tree).java

---
 Medium/Implement Trie II (Prefix Tree).java | 51 +++++++++++----------
 1 file changed, 28 insertions(+), 23 deletions(-)

diff --git a/Medium/Implement Trie II (Prefix Tree).java b/Medium/Implement Trie II (Prefix Tree).java
index a3bddf29..7c5b1a36 100644
--- a/Medium/Implement Trie II (Prefix Tree).java	
+++ b/Medium/Implement Trie II (Prefix Tree).java	
@@ -1,62 +1,67 @@
-public class Trie {
+import java.util.Optional;
 
-    private final TrieNode root;
+
+class Trie {
+
+    private final Node root;
 
     public Trie() {
-        this.root = new TrieNode();
+        root = new Node();
     }
 
     public void insert(String word) {
-        TrieNode curr = root;
+        Node curr = root;
         for (char c : word.toCharArray()) {
             if (!curr.children.containsKey(c)) {
-                curr.children.put(c, new TrieNode());
+                curr.children.put(c, new Node());
             }
             curr = curr.children.get(c);
             curr.startingWordCount++;
         }
-        curr.completeWordCount++;
+        curr.endingWordCount++;
     }
 
     public int countWordsEqualTo(String word) {
-        TrieNode endNode = searchWord(word);
-        return endNode == null ? 0 : endNode.completeWordCount;
+        Optional<Node> curr = search(word);
+        return curr.map(node -> node.endingWordCount).orElse(0);
     }
 
     public int countWordsStartingWith(String prefix) {
-        TrieNode endNode = searchWord(prefix);
-        return endNode == null ? 0 : endNode.startingWordCount;
+        Optional<Node> curr = search(prefix);
+        return curr.map(node -> node.startingWordCount).orElse(0);
     }
 
     public void erase(String word) {
-        TrieNode curr = root;
+        Node curr = root;
         for (char c : word.toCharArray()) {
             curr = curr.children.get(c);
             curr.startingWordCount--;
         }
-        curr.completeWordCount--;
+        curr.endingWordCount--;
     }
 
-    private TrieNode searchWord(String word) {
-        TrieNode curr = root;
+    private Optional<Node> search(String word) {
+        Node curr = root;
         for (char c : word.toCharArray()) {
             if (!curr.children.containsKey(c)) {
-                return null;
+                return Optional.empty();
             }
             curr = curr.children.get(c);
         }
-        return curr;
+        return Optional.of(curr);
     }
 
-    private static class TrieNode {
-        Map<Character, TrieNode> children;
-        int completeWordCount;
-        int startingWordCount;
+    private static class Node {
 
-        public TrieNode() {
-            this.children = new HashMap<>();
-            this.completeWordCount = 0;
+        private int startingWordCount;
+        private int endingWordCount;
+
+        private final Map<Character, Node> children;
+
+        public Node() {
             this.startingWordCount = 0;
+            this.endingWordCount = 0;
+            this.children = new HashMap<>();
         }
     }
 }

From c7f0398ba830f64d54f3de4f344da2c67d2c875f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 2 Oct 2023 06:40:27 -0700
Subject: [PATCH 1819/2175] Create Remove Colored Pieces if Both Neighbors are
 the Same Color.java

---
 ...ces if Both Neighbors are the Same Color.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java

diff --git a/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java b/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java
new file mode 100644
index 00000000..950afa6f
--- /dev/null
+++ b/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public boolean winnerOfGame(String colors) {
+        int alice = 0;
+        int bob = 0;
+        for (int i = 1; i < colors.length() - 1; i++) {
+            if (colors.charAt(i - 1) == colors.charAt(i) && colors.charAt(i + 1) == colors.charAt(i)) {
+                if (colors.charAt(i) == 'A') {
+                    alice++;
+                } else {
+                    bob++;
+                }
+            }
+        }
+        return alice - bob > 0;
+    }
+}

From 64077658a5f27876f8118439012ae020f4a4532c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 2 Oct 2023 17:15:32 -0700
Subject: [PATCH 1820/2175] Update Number of Good Pairs.java

---
 Easy/Number of Good Pairs.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Easy/Number of Good Pairs.java b/Easy/Number of Good Pairs.java
index d3c347af..edb3a754 100644
--- a/Easy/Number of Good Pairs.java	
+++ b/Easy/Number of Good Pairs.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public int numIdenticalPairs(int[] nums) {
-    Map<Integer, Integer> map = new HashMap<>();
-    int count = 0;
-    for (int num : nums) {
-      count += map.getOrDefault(num, 0);
-      map.put(num, map.getOrDefault(num, 0) + 1);
+    public int numIdenticalPairs(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int count = 0;
+        for (int num : nums) {
+            count += map.getOrDefault(num, 0);
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        return count;
     }
-    return count;
-  }
 }

From 13ffcb896d6fe6ffa120ce3d89070d629ca6e41c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Oct 2023 05:30:41 -0700
Subject: [PATCH 1821/2175] Update Design HashMap.java

---
 Easy/Design HashMap.java | 66 +++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 34 deletions(-)

diff --git a/Easy/Design HashMap.java b/Easy/Design HashMap.java
index d59fe9e1..ff29c920 100644
--- a/Easy/Design HashMap.java	
+++ b/Easy/Design HashMap.java	
@@ -1,42 +1,40 @@
 class MyHashMap {
 
-  /** Initialize your data structure here. */
-  Integer[][] map;
-  int NUM_OF_BUCKETS = 1000;
-  int BUCKET_SIZE = 1000;
-  public MyHashMap() {
-    map = new Integer[NUM_OF_BUCKETS][BUCKET_SIZE];
-  }
+    private static final int BUCKET_COUNT = 1001;
 
-  /** value will always be non-negative. */
-  public void put(int key, int value) {
-    Integer[] bucket = getBucket(key);
-    int keyHash = getKeyHash(key);
-    bucket[keyHash] = value;
-  }
+    private static final int BUCKET_SIZE = 1001;
 
-  /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
-  public int get(int key) {
-    Integer[] bucket = getBucket(key);
-    int keyHash = getKeyHash(key);
-    return bucket[keyHash] == null ? -1 : bucket[keyHash];
-  }
+    private final Integer[][] map;
 
-  /** Removes the mapping of the specified value key if this map contains a mapping for the key */
-  public void remove(int key) {
-    Integer[] bucket = getBucket(key);
-    int keyHash = getKeyHash(key);
-    bucket[keyHash] = null;
-  }
-  
-  private Integer[] getBucket(int key) {
-    int bucketIdx = key / BUCKET_SIZE;
-    return map[bucketIdx];
-  }
-  
-  private Integer getKeyHash(int key) {
-    return key % BUCKET_SIZE;
-  }
+    public MyHashMap() {    
+        this.map = new Integer[BUCKET_COUNT][BUCKET_SIZE];
+    }
+    
+    public void put(int key, int value) {
+        Position position = getPosition(key);
+        map[position.bucket()][position.index()] = value;
+    }
+    
+    public int get(int key) {
+        Position position = getPosition(key);
+        Integer value = map[position.bucket()][position.index()];
+        return value == null ? -1 : value;
+    }
+    
+    public void remove(int key) {
+        Position position = getPosition(key);
+        map[position.bucket()][position.index()] = null;
+    }
+
+    private static Position getPosition(int key) {
+        int bucket = key / BUCKET_COUNT;
+        int index = key % BUCKET_SIZE;
+        return new Position(bucket, index);
+    }
+
+    private static record Position(int bucket, int index) {
+      
+    }
 }
 
 /**

From 26fd48c8f78ecbc93eef72f621622e388014f0bb Mon Sep 17 00:00:00 2001
From: varunu28 <varun.u28@gmail.com>
Date: Wed, 4 Oct 2023 12:25:33 -0700
Subject: [PATCH 1822/2175] Updated README

---
 Easy/README.md   | 1179 ++++++++++++++++++-----------------
 Hard/README.md   |  236 +++----
 Medium/README.md | 1547 ++++++++++++++++++++++++----------------------
 README.md        |    6 +-
 4 files changed, 1528 insertions(+), 1440 deletions(-)

diff --git a/Easy/README.md b/Easy/README.md
index d3b1e72e..ff578ea7 100644
--- a/Easy/README.md
+++ b/Easy/README.md
@@ -1,574 +1,609 @@
-# Easy LeetCode Java Solutions 
+# Easy LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1 | [1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
-2 | [A Number After a Double Reversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/A%20Number%20After%20a%20Double%20Reversal.java)
-3 | [Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
-4 | [Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java)
-5 | [Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
-6 | [Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
-7 | [Alternating Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Alternating%20Digit%20Sum.java)
-8 | [Apply Operations to an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Apply%20Operations%20to%20an%20Array.java)
-9 | [Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
-10 | [Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
-11 | [Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
-12 | [Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java)
-13 | [Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
-14 | [Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
-15 | [Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java)
-16 | [Average Value of Even Numbers That Are Divisible by Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Value%20of%20Even%20Numbers%20That%20Are%20Divisible%20by%20Three.java)
-17 | [Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java)
-18 | [Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
-19 | [Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
-20 | [Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
-21 | [Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
-22 | [Best Poker Hand](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Poker%20Hand.java)
-23 | [Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java)
-24 | [Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
-25 | [Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
-26 | [Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
-27 | [Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
-28 | [Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Inorder%20Traversal.java)
-29 | [Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
-30 | [Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
-31 | [Binary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Postorder%20Traversal.java)
-32 | [Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
-33 | [Binary Watch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Watch.java)
-34 | [Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
-35 | [Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java)
-36 | [Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java)
-37 | [Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java)
-38 | [Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java)
-39 | [Calculate Delayed Arrival Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Delayed%20Arrival%20Time.java)
-40 | [Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java)
-41 | [Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
-42 | [Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
-43 | [Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
-44 | [Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java)
-45 | [Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java)
-46 | [Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java)
-47 | [Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
-48 | [Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
-49 | [Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java)
-50 | [Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
-51 | [Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
-52 | [Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
-53 | [Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
-54 | [Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
-55 | [Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
-56 | [Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java)
-57 | [Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java)
-58 | [Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
-59 | [Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
-60 | [Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
-61 | [Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
-62 | [Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java)
-63 | [Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java)
-64 | [Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java)
-65 | [Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java)
-66 | [Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
-67 | [Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java)
-68 | [Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
-69 | [Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java)
-70 | [Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
-71 | [Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java)
-72 | [Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
-73 | [Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
-74 | [Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
-75 | [Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
-76 | [Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
-77 | [Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
-78 | [Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
-79 | [Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
-80 | [Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
-81 | [Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
-82 | [Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java)
-83 | [Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java)
-84 | [Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
-85 | [Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
-86 | [Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
-87 | [Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
-88 | [Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java)
-89 | [Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java)
-90 | [Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
-91 | [Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java)
-92 | [Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java)
-93 | [Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java)
-94 | [Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java)
-95 | [Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
-96 | [Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java)
-97 | [Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java)
-98 | [Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
-99 | [Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
-100 | [Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
-101 | [Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java)
-102 | [Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
-103 | [Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java)
-104 | [Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java)
-105 | [Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java)
-106 | [Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
-107 | [Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java)
-108 | [Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
-109 | [Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
-110 | [Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java)
-111 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
-112 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java)
-113 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
-114 | [Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java)
-115 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java)
-116 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
-117 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java)
-118 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
-119 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
-120 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
-121 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
-122 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
-123 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
-124 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
-125 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java)
-126 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
-127 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
-128 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
-129 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
-130 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
-131 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
-132 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
-133 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
-134 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java)
-135 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
-136 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
-137 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
-138 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
-139 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
-140 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java)
-141 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
-142 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
-143 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
-144 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
-145 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
-146 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
-147 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
-148 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java)
-149 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
-150 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
-151 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java)
-152 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
-153 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
-154 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
-155 | [Distribute Money to Maximum Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Money%20to%20Maximum%20Children.java)
-156 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java)
-157 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java)
-158 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
-159 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
-160 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
-161 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
-162 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java)
-163 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
-164 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
-165 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
-166 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
-167 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java)
-168 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
-169 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java)
-170 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java)
-171 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
-172 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
-173 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
-174 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java)
-175 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
-176 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java)
-177 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
-178 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
-179 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
-180 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
-181 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
-182 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
-183 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
-184 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
-185 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java)
-186 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
-187 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java)
-188 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java)
-189 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
-190 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
-191 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java)
-192 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java)
-193 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java)
-194 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
-195 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
-196 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java)
-197 | [Find the Longest Balanced Substring of a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Longest%20Balanced%20Substring%20of%20a%20Binary%20String.java)
-198 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java)
-199 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
-200 | [Find the Width of Columns of a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Width%20of%20Columns%20of%20a%20Grid.java)
-201 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
-202 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java)
-203 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
-204 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java)
-205 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
-206 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
-207 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
-208 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
-209 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
-210 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
-211 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
-212 | [Form Smallest Number From Two Digit Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Form%20Smallest%20Number%20From%20Two%20Digit%20Arrays.java)
-213 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
-214 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
-215 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
-216 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
-217 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
-218 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java)
-219 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
-220 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
-221 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
-222 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
-223 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
-224 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
-225 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
-226 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
-227 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
-228 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
-229 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
-230 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
-231 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
-232 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
-233 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
-234 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
-235 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
-236 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java)
-237 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
-238 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java)
-239 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
-240 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
-241 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
-242 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
-243 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
-244 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
-245 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
-246 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
-247 | [K Items With the Maximum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Items%20With%20the%20Maximum%20Sum.java)
-248 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
-249 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java)
-250 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
-251 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
-252 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java)
-253 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
-254 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
-255 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java)
-256 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java)
-257 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java)
-258 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
-259 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
-260 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
-261 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java)
-262 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
-263 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
-264 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
-265 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
-266 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
-267 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
-268 | [Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java)
-269 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
-270 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
-271 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
-272 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
-273 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
-274 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
-275 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
-276 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
-277 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
-278 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
-279 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
-280 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
-281 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
-282 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java)
-283 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
-284 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
-285 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
-286 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
-287 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
-288 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
-289 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
-290 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java)
-291 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
-292 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
-293 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
-294 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
-295 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java)
-296 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
-297 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
-298 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
-299 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java)
-300 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
-301 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java)
-302 | [Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java)
-303 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
-304 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java)
-305 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
-306 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
-307 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
-308 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java)
-309 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java)
-310 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
-311 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
-312 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
-313 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java)
-314 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
-315 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
-316 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
-317 | [Maximum Sum With Exactly K Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Sum%20With%20Exactly%20K%20Elements.java)
-318 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
-319 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java)
-320 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
-321 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
-322 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
-323 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java)
-324 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
-325 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
-326 | [Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java)
-327 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
-328 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
-329 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
-330 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
-331 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java)
-332 | [Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
-333 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
-334 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java)
-335 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java)
-336 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
-337 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java)
-338 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java)
-339 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java)
-340 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java)
-341 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
-342 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
-343 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
-344 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
-345 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java)
-346 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
-347 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java)
-348 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
-349 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java)
-350 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java)
-351 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
-352 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java)
-353 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
-354 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java)
-355 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
-356 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
-357 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
-358 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
-359 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
-360 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
-361 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java)
-362 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
-363 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
-364 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java)
-365 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java)
-366 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
-367 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
-368 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
-369 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
-370 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
-371 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
-372 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
-373 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
-374 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
-375 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
-376 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
-377 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
-378 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
-379 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
-380 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java)
-381 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
-382 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java)
-383 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
-384 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
-385 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
-386 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java)
-387 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
-388 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
-389 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
-390 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
-391 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
-392 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
-393 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
-394 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
-395 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java)
-396 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java)
-397 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
-398 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
-399 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java)
-400 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
-401 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
-402 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
-403 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
-404 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
-405 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
-406 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
-407 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
-408 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
-409 | [Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java)
-410 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
-411 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
-412 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
-413 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
-414 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java)
-415 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
-416 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
-417 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
-418 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
-419 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java)
-420 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
-421 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
-422 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
-423 | [Prime In Diagonal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Prime%20In%20Diagonal.java)
-424 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
-425 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
-426 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java)
-427 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
-428 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
-429 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
-430 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java)
-431 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
-432 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java)
-433 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
-434 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
-435 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
-436 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
-437 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
-438 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
-439 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
-440 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java)
-441 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
-442 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
-443 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
-444 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java)
-445 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
-446 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
-447 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
-448 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java)
-449 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
-450 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
-451 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
-452 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
-453 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
-454 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
-455 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
-456 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
-457 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
-458 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
-459 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java)
-460 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
-461 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
-462 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
-463 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
-464 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
-465 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java)
-466 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
-467 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
-468 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java)
-469 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
-470 | [Row With Maximum Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Row%20With%20Maximum%20Ones.java)
-471 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
-472 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
-473 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
-474 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
-475 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
-476 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
-477 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
-478 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
-479 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java)
-480 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
-481 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
-482 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java)
-483 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
-484 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
-485 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
-486 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
-487 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
-488 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java)
-489 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
-490 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
-491 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
-492 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java)
-493 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java)
-494 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
-495 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
-496 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
-497 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
-498 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java)
-499 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
-500 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java)
-501 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
-502 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
-503 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
-504 | [Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java)
-505 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
-506 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
-507 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
-508 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
-509 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
-510 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
-511 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java)
-512 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
-513 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
-514 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
-515 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
-516 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
-517 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java)
-518 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
-519 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
-520 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
-521 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
-522 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java)
-523 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
-524 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
-525 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
-526 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
-527 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
-528 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java)
-529 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java)
-530 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
-531 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java)
-532 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
-533 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
-534 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
-535 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
-536 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
-537 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java)
-538 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
-539 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
-540 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
-541 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
-542 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java)
-543 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java)
-544 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
-545 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
-546 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
-547 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
-548 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
-549 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
-550 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
-551 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
-552 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
-553 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
-554 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
-555 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
-556 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
-557 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
-558 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
-559 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
-560 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
-561 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java)
-562 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
-563 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java)
-564 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
-565 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
-566 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
-567 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
-568 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java)
-569 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
-570 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
-571 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
+1|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
+2|[Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java)
+3|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
+4|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java)
+5|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
+6|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
+7|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
+8|[Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
+9|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
+10|[Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java)
+11|[Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
+12|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
+13|[Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
+14|[Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
+15|[Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java)
+16|[The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
+17|[Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
+18|[Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
+19|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
+20|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
+21|[Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
+22|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
+23|[Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java)
+24|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
+25|[Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
+26|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
+27|[Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java)
+28|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
+29|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
+30|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
+31|[Find the Distinct Difference Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distinct%20Difference%20Array.java)
+32|[Buy Two Chocolates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buy%20Two%20Chocolates.java)
+33|[Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java)
+34|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
+35|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java)
+36|[Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
+37|[Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
+38|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
+39|[Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java)
+40|[Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java)
+41|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
+42|[X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
+43|[Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
+44|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
+45|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
+46|[Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
+47|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
+48|[Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
+49|[Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
+50|[Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
+51|[Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
+52|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
+53|[Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
+54|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
+55|[Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
+56|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
+57|[Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
+58|[Check if The Number is Fascinating](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20The%20Number%20is%20Fascinating.java)
+59|[Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java)
+60|[Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
+61|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
+62|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
+63|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
+64|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
+65|[Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java)
+66|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
+67|[Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
+68|[Remove Trailing Zeros From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Trailing%20Zeros%20From%20a%20String.java)
+69|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
+70|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
+71|[XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java)
+72|[Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java)
+73|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
+74|[Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
+75|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
+76|[Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
+77|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
+78|[Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
+79|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
+80|[Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java)
+81|[Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java)
+82|[Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java)
+83|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
+84|[Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java)
+85|[Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
+86|[Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java)
+87|[Split Strings by Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20Strings%20by%20Separator.java)
+88|[Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java)
+89|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
+90|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
+91|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
+92|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
+93|[Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java)
+94|[Find the Width of Columns of a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Width%20of%20Columns%20of%20a%20Grid.java)
+95|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
+96|[Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java)
+97|[Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
+98|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
+99|[Best Poker Hand](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Poker%20Hand.java)
+100|[Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java)
+101|[Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
+102|[Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
+103|[Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
+104|[Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java)
+105|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
+106|[Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
+107|[Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
+108|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
+109|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
+110|[Points That Intersect With Cars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Points%20That%20Intersect%20With%20Cars.java)
+111|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
+112|[Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
+113|[Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
+114|[Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java)
+115|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
+116|[Neither Minimum nor Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Neither%20Minimum%20nor%20Maximum.java)
+117|[Maximum Value of an Ordered Triplet I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20an%20Ordered%20Triplet%20I.java)
+118|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
+119|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
+120|[Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java)
+121|[Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
+122|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
+123|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
+124|[Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
+125|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
+126|[Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java)
+127|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
+128|[Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
+129|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
+130|[Row With Maximum Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Row%20With%20Maximum%20Ones.java)
+131|[Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
+132|[Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
+133|[Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
+134|[Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
+135|[Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
+136|[Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
+137|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
+138|[Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
+139|[Average Value of Even Numbers That Are Divisible by Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Value%20of%20Even%20Numbers%20That%20Are%20Divisible%20by%20Three.java)
+140|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
+141|[Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
+142|[Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
+143|[DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
+144|[Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
+145|[Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
+146|[Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java)
+147|[Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java)
+148|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
+149|[Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java)
+150|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
+151|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
+152|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
+153|[Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
+154|[Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java)
+155|[Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
+156|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
+157|[Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
+158|[Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
+159|[Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
+160|[Check if Array is Good](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20is%20Good.java)
+161|[Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
+162|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
+163|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
+164|[Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java)
+165|[Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
+166|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
+167|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
+168|[Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
+169|[Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
+170|[Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java)
+171|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
+172|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
+173|[Number of Beautiful Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Beautiful%20Pairs.java)
+174|[Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
+175|[Furthest Point From Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Furthest%20Point%20From%20Origin.java)
+176|[Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
+177|[Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java)
+178|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
+179|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
+180|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
+181|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
+182|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
+183|[Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java)
+184|[Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
+185|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
+186|[Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
+187|[Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java)
+188|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
+189|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
+190|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
+191|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
+192|[Sum of Values at Indices With K Set Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Values%20at%20Indices%20With%20K%20Set%20Bits.java)
+193|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
+194|[Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
+195|[Binary Watch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Watch.java)
+196|[Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java)
+197|[Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
+198|[Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java)
+199|[Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
+200|[Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java)
+201|[Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java)
+202|[String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
+203|[Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java)
+204|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
+205|[Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
+206|[Faulty Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Faulty%20Keyboard.java)
+207|[Find the Pivot Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Pivot%20Integer.java)
+208|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
+209|[Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java)
+210|[Count Symmetric Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Symmetric%20Integers.java)
+211|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
+212|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
+213|[Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
+214|[Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java)
+215|[Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
+216|[Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
+217|[Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java)
+218|[Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
+219|[Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
+220|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
+221|[Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java)
+222|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Inorder%20Traversal.java)
+223|[Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java)
+224|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
+225|[Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java)
+226|[Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
+227|[Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
+228|[Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
+229|[Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java)
+230|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
+231|[Count Pairs Whose Sum is Less than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Whose%20Sum%20is%20Less%20than%20Target.java)
+232|[Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
+233|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
+234|[Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
+235|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
+236|[Delete Greatest Value in Each Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Greatest%20Value%20in%20Each%20Row.java)
+237|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
+238|[First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java)
+239|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
+240|[Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
+241|[Find the Maximum Achievable Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Maximum%20Achievable%20Number.java)
+242|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
+243|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
+244|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
+245|[Check if Strings Can be Made Equal With Operations I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Strings%20Can%20be%20Made%20Equal%20With%20Operations%20I.java)
+246|[Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java)
+247|[Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java)
+248|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
+249|[Longest Even Odd Subarray With Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Even%20Odd%20Subarray%20With%20Threshold.java)
+250|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
+251|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
+252|[Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
+253|[Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
+254|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
+255|[Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java)
+256|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
+257|[Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
+258|[Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java)
+259|[Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
+260|[Number of Employees Who Met the Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Employees%20Who%20Met%20the%20Target.java)
+261|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
+262|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
+263|[Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java)
+264|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
+265|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
+266|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
+267|[Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java)
+268|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
+269|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
+270|[Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
+271|[Number of Senior Citizens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Senior%20Citizens.java)
+272|[Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java)
+273|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
+274|[Longest Alternating Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Alternating%20Subarray.java)
+275|[Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
+276|[Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
+277|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
+278|[Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java)
+279|[A Number After a Double Reversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/A%20Number%20After%20a%20Double%20Reversal.java)
+280|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
+281|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
+282|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
+283|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
+284|[Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java)
+285|[Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
+286|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
+287|[Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java)
+288|[Minimum String Length After Removing Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20String%20Length%20After%20Removing%20Substrings.java)
+289|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
+290|[Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java)
+291|[Account Balance After Rounded Purchase](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Account%20Balance%20After%20Rounded%20Purchase.java)
+292|[Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java)
+293|[Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
+294|[Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java)
+295|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
+296|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
+297|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
+298|[How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
+299|[Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java)
+300|[Maximum Odd Binary Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Odd%20Binary%20Number.java)
+301|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
+302|[Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
+303|[Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
+304|[Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
+305|[Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
+306|[Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
+307|[Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
+308|[Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
+309|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
+310|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
+311|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
+312|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
+313|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
+314|[The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java)
+315|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
+316|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
+317|[Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
+318|[Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java)
+319|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
+320|[Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
+321|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
+322|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
+323|[Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java)
+324|[Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
+325|[Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java)
+326|[Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java)
+327|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
+328|[First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
+329|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
+330|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
+331|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
+332|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
+333|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
+334|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
+335|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
+336|[Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java)
+337|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
+338|[Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
+339|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
+340|[Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java)
+341|[Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java)
+342|[Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java)
+343|[Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java)
+344|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
+345|[Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
+346|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
+347|[Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java)
+348|[Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
+349|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
+350|[Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java)
+351|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
+352|[Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java)
+353|[Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
+354|[Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
+355|[Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java)
+356|[Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java)
+357|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
+358|[Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java)
+359|[Sum of Squares of Special Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Squares%20of%20Special%20Elements.java)
+360|[Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java)
+361|[Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
+362|[Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
+363|[Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
+364|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
+365|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
+366|[Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java)
+367|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
+368|[Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
+369|[Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java)
+370|[Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
+371|[Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
+372|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
+373|[Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
+374|[Calculate Delayed Arrival Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Delayed%20Arrival%20Time.java)
+375|[Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
+376|[Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
+377|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
+378|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
+379|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
+380|[Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
+381|[Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
+382|[Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
+383|[Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
+384|[Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
+385|[Find the Losers of the Circular Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Losers%20of%20the%20Circular%20Game.java)
+386|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
+387|[K Items With the Maximum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Items%20With%20the%20Maximum%20Sum.java)
+388|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
+389|[Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java)
+390|[Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java)
+391|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
+392|[Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
+393|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java)
+394|[Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
+395|[Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java)
+396|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
+397|[Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java)
+398|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
+399|[Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
+400|[Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java)
+401|[Form Smallest Number From Two Digit Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Form%20Smallest%20Number%20From%20Two%20Digit%20Arrays.java)
+402|[Minimum Operations to Collect Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Collect%20Elements.java)
+403|[Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java)
+404|[Determine the Winner of a Bowling Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20the%20Winner%20of%20a%20Bowling%20Game.java)
+405|[Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
+406|[Minimum Right Shifts to Sort the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Right%20Shifts%20to%20Sort%20the%20Array.java)
+407|[Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
+408|[Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
+409|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
+410|[Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
+411|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
+412|[Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java)
+413|[Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java)
+414|[Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
+415|[Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
+416|[Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java)
+417|[Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
+418|[Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java)
+419|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
+420|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
+421|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
+422|[Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
+423|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
+424|[Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java)
+425|[Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
+426|[Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java)
+427|[Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
+428|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
+429|[Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
+430|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
+431|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
+432|[Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
+433|[Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java)
+434|[Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
+435|[Minimize String Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimize%20String%20Length.java)
+436|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
+437|[Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
+438|[Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java)
+439|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
+440|[Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
+441|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
+442|[Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java)
+443|[Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
+444|[Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
+445|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
+446|[Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java)
+447|[Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
+448|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java)
+449|[Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
+450|[Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java)
+451|[Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java)
+452|[Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
+453|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
+454|[Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
+455|[Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
+456|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
+457|[Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
+458|[Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
+459|[Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java)
+460|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
+461|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
+462|[Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java)
+463|[Total Distance Traveled](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Total%20Distance%20Traveled.java)
+464|[Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java)
+465|[Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
+466|[Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
+467|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
+468|[Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
+469|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
+470|[Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
+471|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
+472|[Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java)
+473|[Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java)
+474|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
+475|[Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
+476|[Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java)
+477|[Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java)
+478|[Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java)
+479|[Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
+480|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
+481|[Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java)
+482|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
+483|[Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
+484|[Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java)
+485|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
+486|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
+487|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
+488|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
+489|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
+490|[Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java)
+491|[Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
+492|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
+493|[Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
+494|[Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java)
+495|[Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java)
+496|[Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java)
+497|[Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java)
+498|[Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java)
+499|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
+500|[Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
+501|[Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
+502|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
+503|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
+504|[Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
+505|[Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java)
+506|[Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
+507|[Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
+508|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
+509|[Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java)
+510|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java)
+511|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
+512|[Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java)
+513|[Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
+514|[Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java)
+515|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
+516|[Distribute Money to Maximum Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Money%20to%20Maximum%20Children.java)
+517|[Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
+518|[Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java)
+519|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
+520|[Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java)
+521|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
+522|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
+523|[Alternating Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Alternating%20Digit%20Sum.java)
+524|[Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java)
+525|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
+526|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
+527|[Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
+528|[Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java)
+529|[Apply Operations to an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Apply%20Operations%20to%20an%20Array.java)
+530|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
+531|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
+532|[Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java)
+533|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
+534|[Find the Longest Balanced Substring of a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Longest%20Balanced%20Substring%20of%20a%20Binary%20String.java)
+535|[Binary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Postorder%20Traversal.java)
+536|[Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
+537|[Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java)
+538|[Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
+539|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
+540|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
+541|[Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
+542|[Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java)
+543|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
+544|[Maximum Sum With Exactly K Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Sum%20With%20Exactly%20K%20Elements.java)
+545|[Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
+546|[Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java)
+547|[Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java)
+548|[Check if a String Is an Acronym of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20a%20String%20Is%20an%20Acronym%20of%20Words.java)
+549|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
+550|[Max Pair Sum in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Pair%20Sum%20in%20an%20Array.java)
+551|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
+552|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
+553|[Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
+554|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
+555|[Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
+556|[Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
+557|[Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
+558|[Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
+559|[Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
+560|[Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
+561|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
+562|[Prime In Diagonal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Prime%20In%20Diagonal.java)
+563|[Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java)
+564|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
+565|[Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java)
+566|[Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java)
+567|[Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
+568|[Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
+569|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
+570|[Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
+571|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
+572|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
+573|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
+574|[Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java)
+575|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
+576|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
+577|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
+578|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
+579|[Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
+580|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
+581|[Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
+582|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
+583|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
+584|[Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java)
+585|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
+586|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
+587|[Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
+588|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
+589|[Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
+590|[Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java)
+591|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
+592|[Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java)
+593|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
+594|[Find Maximum Number of String Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Maximum%20Number%20of%20String%20Pairs.java)
+595|[Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java)
+596|[Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java)
+597|[Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
+598|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
+599|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
+600|[Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java)
+601|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
+602|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
+603|[Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
+604|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
+605|[Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java)
+606|[Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
diff --git a/Hard/README.md b/Hard/README.md
index e97d573a..0e44bb8b 100644
--- a/Hard/README.md
+++ b/Hard/README.md
@@ -1,113 +1,127 @@
-# Hard LeetCode Java Solutions 
+# Hard LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1 | [Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java)
-2 | [Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Alien%20Dictionary.java)
-3 | [Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
-4 | [Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
-5 | [Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java)
-6 | [Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java)
-7 | [Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
-8 | [Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
-9 | [Checking Existence of Edge Length Limited Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Checking%20Existence%20of%20Edge%20Length%20Limited%20Paths.java)
-10 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
-11 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
-12 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java)
-13 | [Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java)
-14 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java)
-15 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java)
-16 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java)
-17 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java)
-18 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
-19 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java)
-20 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java)
-21 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
-22 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java)
-23 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java)
-24 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
-25 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
-26 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
-27 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java)
-28 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java)
-29 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
-30 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java)
-31 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
-32 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
-33 | [IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java)
-34 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
-35 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
-36 | [Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java)
-37 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
-38 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java)
-39 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java)
-40 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
-41 | [Largest Color Value in a Directed Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Color%20Value%20in%20a%20Directed%20Graph.java)
-42 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
-43 | [Longest Cycle in a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Cycle%20in%20a%20Graph.java)
-44 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
-45 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
-46 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java)
-47 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java)
-48 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java)
-49 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
-50 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
-51 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java)
-52 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java)
-53 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
-54 | [Maximum Value of K Coins From Piles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Value%20of%20K%20Coins%20From%20Piles.java)
-55 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
-56 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
-57 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
-58 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
-59 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java)
-60 | [Minimum Insertion Steps to Make a String Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Insertion%20Steps%20to%20Make%20a%20String%20Palindrome.java)
-61 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java)
-62 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java)
-63 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
-64 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java)
-65 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java)
-66 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
-67 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java)
-68 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
-69 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
-70 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
-71 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
-72 | [Number of Ways of Cutting a Pizza](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20of%20Cutting%20a%20Pizza.java)
-73 | [Number of Ways to Form a Target String Given a Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Form%20a%20Target%20String%20Given%20a%20Dictionary.java)
-74 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
-75 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
-76 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java)
-77 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
-78 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
-79 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java)
-80 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java)
-81 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
-82 | [Profitable Schemes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Profitable%20Schemes.java)
-83 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java)
-84 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
-85 | [Reducing Dishes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reducing%20Dishes.java)
-86 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
-87 | [Restore The Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Restore%20The%20Array.java)
-88 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
-89 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
-90 | [Scramble String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Scramble%20String.java)
-91 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
-92 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
-93 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
-94 | [Similar String Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Similar%20String%20Groups.java)
-95 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
-96 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
-97 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java)
-98 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
-99 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java)
-100 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
-101 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
-102 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
-103 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java)
-104 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
-105 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
-106 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
-107 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java)
-108 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java)
-109 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
-110 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
+1|[Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
+2|[Minimum Cost to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Make%20Array%20Equal.java)
+3|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java)
+4|[Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java)
+5|[Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java)
+6|[Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
+7|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
+8|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java)
+9|[Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
+10|[Sort Items by Groups Respecting Dependencies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sort%20Items%20by%20Groups%20Respecting%20Dependencies.java)
+11|[Shortest Path Visiting All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Path%20Visiting%20All%20Nodes.java)
+12|[Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java)
+13|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
+14|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
+15|[Checking Existence of Edge Length Limited Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Checking%20Existence%20of%20Edge%20Length%20Limited%20Paths.java)
+16|[Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java)
+17|[Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java)
+18|[Remove Max Number of Edges to Keep Graph Fully Traversable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Max%20Number%20of%20Edges%20to%20Keep%20Graph%20Fully%20Traversable.java)
+19|[K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java)
+20|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
+21|[Minimum Replacements to Sort the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Replacements%20to%20Sort%20the%20Array.java)
+22|[Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java)
+23|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
+24|[My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java)
+25|[Longest Cycle in a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Cycle%20in%20a%20Graph.java)
+26|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
+27|[Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java)
+28|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
+29|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
+30|[Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java)
+31|[Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java)
+32|[Rearrange String k Distance Apart](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Rearrange%20String%20k%20Distance%20Apart.java)
+33|[Make Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Make%20Array%20Strictly%20Increasing.java)
+34|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
+35|[Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java)
+36|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
+37|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
+38|[Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
+39|[Paint House II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20II.java)
+40|[Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
+41|[Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java)
+42|[Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java)
+43|[Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java)
+44|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
+45|[Scramble String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Scramble%20String.java)
+46|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
+47|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
+48|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
+49|[Maximize Score After N Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximize%20Score%20After%20N%20Operations.java)
+50|[Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java)
+51|[The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java)
+52|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
+53|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
+54|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
+55|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
+56|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
+57|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
+58|[Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java)
+59|[String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java)
+60|[Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
+61|[Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
+62|[Find the Longest Valid Obstacle Course at Each Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Longest%20Valid%20Obstacle%20Course%20at%20Each%20Position.java)
+63|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
+64|[Maximum Value of K Coins From Piles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Value%20of%20K%20Coins%20From%20Piles.java)
+65|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
+66|[Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
+67|[Profitable Schemes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Profitable%20Schemes.java)
+68|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
+69|[Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
+70|[N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java)
+71|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
+72|[Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java)
+73|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
+74|[Number of Ways of Cutting a Pizza](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20of%20Cutting%20a%20Pizza.java)
+75|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md)
+76|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
+77|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
+78|[Similar String Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Similar%20String%20Groups.java)
+79|[Number of Ways to Form a Target String Given a Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Form%20a%20Target%20String%20Given%20a%20Dictionary.java)
+80|[Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java)
+81|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
+82|[Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java)
+83|[Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java)
+84|[Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java)
+85|[Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java)
+86|[Number of Ways to Reorder Array to Get Same BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Reorder%20Array%20to%20Get%20Same%20BST.java)
+87|[Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java)
+88|[Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java)
+89|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
+90|[Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java)
+91|[Stone Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stone%20Game%20III.java)
+92|[Reducing Dishes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reducing%20Dishes.java)
+93|[Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java)
+94|[Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java)
+95|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
+96|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
+97|[Minimum Insertion Steps to Make a String Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Insertion%20Steps%20to%20Make%20a%20String%20Palindrome.java)
+98|[Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
+99|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
+100|[Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java)
+101|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
+102|[Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java)
+103|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
+104|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
+105|[Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Alien%20Dictionary.java)
+106|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
+107|[Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java)
+108|[Tallest Billboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Tallest%20Billboard.java)
+109|[Largest Color Value in a Directed Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Color%20Value%20in%20a%20Directed%20Graph.java)
+110|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
+111|[Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java)
+112|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
+113|[Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
+114|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
+115|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
+116|[Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java)
+117|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
+118|[Restore The Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Restore%20The%20Array.java)
+119|[IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java)
+120|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
+121|[Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java)
+122|[Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
+123|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
+124|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
diff --git a/Medium/README.md b/Medium/README.md
index 0d6a9299..cb496742 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -1,756 +1,795 @@
-# Medium LeetCode Java Solutions 
+# Medium LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1 | [01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
-2 | [132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java)
-3 | [3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
-4 | [3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
-5 | [3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java)
-6 | [3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
-7 | [4 Keys Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Keys%20Keyboard.java)
-8 | [4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
-9 | [4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
-10 | [4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
-11 | [Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
-12 | [Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
-13 | [Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
-14 | [Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
-15 | [Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
-16 | [Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
-17 | [Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java)
-18 | [Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
-19 | [Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
-20 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
-21 | [All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java)
-22 | [All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java)
-23 | [All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
-24 | [All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
-25 | [All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
-26 | [All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
-27 | [All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
-28 | [Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
-29 | [Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
-30 | [Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java)
-31 | [Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java)
-32 | [Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
-33 | [Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java)
-34 | [Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
-35 | [Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
-36 | [Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
-37 | [Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
-38 | [As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
-39 | [Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
-40 | [Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
-41 | [Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java)
-42 | [Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java)
-43 | [Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
-44 | [Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
-45 | [Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java)
-46 | [Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
-47 | [Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java)
-48 | [Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
-49 | [Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
-50 | [Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
-51 | [Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java)
-52 | [Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
-53 | [Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
-54 | [Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
-55 | [Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
-56 | [Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
-57 | [Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
-58 | [Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
-59 | [Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
-60 | [Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java)
-61 | [Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
-62 | [Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
-63 | [Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java)
-64 | [Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java)
-65 | [Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
-66 | [Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java)
-67 | [Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
-68 | [Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
-69 | [Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java)
-70 | [Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
-71 | [Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
-72 | [Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
-73 | [Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
-74 | [Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
-75 | [Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
-76 | [Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
-77 | [Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
-78 | [Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
-79 | [Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
-80 | [Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java)
-81 | [Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
-82 | [Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
-83 | [Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
-84 | [Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
-85 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
-86 | [Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
-87 | [Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
-88 | [Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
-89 | [Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
-90 | [Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
-91 | [Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java)
-92 | [Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
-93 | [Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
-94 | [Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
-95 | [Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
-96 | [Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java)
-97 | [Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
-98 | [Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
-99 | [Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
-100 | [Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
-101 | [Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
-102 | [Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java)
-103 | [Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java)
-104 | [Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
-105 | [Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
-106 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java)
-107 | [Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
-108 | [Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
-109 | [Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java)
-110 | [Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
-111 | [Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
-112 | [Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
-113 | [Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java)
-114 | [Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
-115 | [Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
-116 | [Convert an Array Into a 2D Array With Conditions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20an%20Array%20Into%20a%202D%20Array%20With%20Conditions.java)
-117 | [Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
-118 | [Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
-119 | [Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java)
-120 | [Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
-121 | [Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
-122 | [Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java)
-123 | [Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java)
-124 | [Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java)
-125 | [Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java)
-126 | [Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
-127 | [Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
-128 | [Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
-129 | [Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
-130 | [Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
-131 | [Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
-132 | [Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java)
-133 | [Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
-134 | [Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
-135 | [Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java)
-136 | [Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java)
-137 | [Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java)
-138 | [Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
-139 | [Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
-140 | [Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java)
-141 | [Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
-142 | [Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
-143 | [Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
-144 | [Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
-145 | [Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
-146 | [Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
-147 | [Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
-148 | [Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
-149 | [Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
-150 | [Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
-151 | [Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
-152 | [Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java)
-153 | [Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
-154 | [Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java)
-155 | [Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
-156 | [Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
-157 | [Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
-158 | [Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
-159 | [Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
-160 | [Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java)
-161 | [Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
-162 | [Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
-163 | [Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
-164 | [Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java)
-165 | [Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java)
-166 | [Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
-167 | [Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
-168 | [Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
-169 | [Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
-170 | [Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
-171 | [Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java)
-172 | [Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java)
-173 | [Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
-174 | [Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
-175 | [Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
-176 | [Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
-177 | [Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
-178 | [Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
-179 | [Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java)
-180 | [Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
-181 | [Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
-182 | [Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
-183 | [Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
-184 | [Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java)
-185 | [Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
-186 | [Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
-187 | [Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
-188 | [Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java)
-189 | [Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
-190 | [Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
-191 | [Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java)
-192 | [Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
-193 | [Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java)
-194 | [Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
-195 | [Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
-196 | [Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java)
-197 | [Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java)
-198 | [Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
-199 | [Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
-200 | [Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java)
-201 | [Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java)
-202 | [Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java)
-203 | [Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
-204 | [Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
-205 | [Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
-206 | [Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
-207 | [Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
-208 | [Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
-209 | [Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
-210 | [Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
-211 | [Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
-212 | [Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
-213 | [Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java)
-214 | [Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
-215 | [Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java)
-216 | [Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
-217 | [Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
-218 | [Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java)
-219 | [Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
-220 | [Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
-221 | [Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
-222 | [Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java)
-223 | [Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java)
-224 | [Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
-225 | [Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
-226 | [Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
-227 | [Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
-228 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
-229 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
-230 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java)
-231 | [Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java)
-232 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
-233 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
-234 | [Find the Maximum Divisibility Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Maximum%20Divisibility%20Score.java)
-235 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java)
-236 | [Find the Score of All Prefixes of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array.java)
-237 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
-238 | [Find the Substring With Maximum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Substring%20With%20Maximum%20Cost.java)
-239 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
-240 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
-241 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
-242 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
-243 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
-244 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
-245 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
-246 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
-247 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
-248 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
-249 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
-250 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java)
-251 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
-252 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java)
-253 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
-254 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
-255 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
-256 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
-257 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
-258 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
-259 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
-260 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
-261 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
-262 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
-263 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
-264 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
-265 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
-266 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
-267 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
-268 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
-269 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java)
-270 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java)
-271 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
-272 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
-273 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
-274 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java)
-275 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
-276 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
-277 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
-278 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
-279 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
-280 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
-281 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java)
-282 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
-283 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
-284 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
-285 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
-286 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
-287 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
-288 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java)
-289 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
-290 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
-291 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
-292 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
-293 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java)
-294 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java)
-295 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java)
-296 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
-297 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java)
-298 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java)
-299 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
-300 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
-301 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
-302 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
-303 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
-304 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
-305 | [Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java)
-306 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
-307 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
-308 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java)
-309 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
-310 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
-311 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
-312 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java)
-313 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
-314 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
-315 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
-316 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
-317 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java)
-318 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
-319 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
-320 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java)
-321 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java)
-322 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
-323 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
-324 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
-325 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
-326 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
-327 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
-328 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
-329 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
-330 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java)
-331 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
-332 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
-333 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java)
-334 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
-335 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
-336 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
-337 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
-338 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java)
-339 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
-340 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
-341 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
-342 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java)
-343 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
-344 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java)
-345 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
-346 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
-347 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
-348 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java)
-349 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
-350 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
-351 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
-352 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
-353 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
-354 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java)
-355 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java)
-356 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
-357 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
-358 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
-359 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
-360 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java)
-361 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
-362 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java)
-363 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
-364 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java)
-365 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java)
-366 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
-367 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java)
-368 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
-369 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java)
-370 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
-371 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
-372 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java)
-373 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
-374 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
-375 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
-376 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
-377 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
-378 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java)
-379 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
-380 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
-381 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java)
-382 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java)
-383 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java)
-384 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java)
-385 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java)
-386 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java)
-387 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
-388 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
-389 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
-390 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java)
-391 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
-392 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java)
-393 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java)
-394 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
-395 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java)
-396 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
-397 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java)
-398 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java)
-399 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java)
-400 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java)
-401 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java)
-402 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java)
-403 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java)
-404 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
-405 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
-406 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
-407 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
-408 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
-409 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
-410 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
-411 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
-412 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
-413 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java)
-414 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java)
-415 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java)
-416 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
-417 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
-418 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
-419 | [Minimize Maximum of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20of%20Array.java)
-420 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java)
-421 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
-422 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java)
-423 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
-424 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java)
-425 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java)
-426 | [Minimum Cost For Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20For%20Tickets.java)
-427 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
-428 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
-429 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java)
-430 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
-431 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
-432 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java)
-433 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java)
-434 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
-435 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java)
-436 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
-437 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
-438 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
-439 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java)
-440 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java)
-441 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
-442 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java)
-443 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
-444 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
-445 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
-446 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
-447 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
-448 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
-449 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java)
-450 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
-451 | [Minimum Score of a Path Between Two Cities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20of%20a%20Path%20Between%20Two%20Cities.java)
-452 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
-453 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java)
-454 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
-455 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java)
-456 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java)
-457 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java)
-458 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java)
-459 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
-460 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
-461 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java)
-462 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java)
-463 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
-464 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
-465 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
-466 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
-467 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java)
-468 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java)
-469 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
-470 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
-471 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
-472 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
-473 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
-474 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
-475 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java)
-476 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
-477 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java)
-478 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
-479 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java)
-480 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
-481 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java)
-482 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
-483 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
-484 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
-485 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java)
-486 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java)
-487 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
-488 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java)
-489 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
-490 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
-491 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
-492 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
-493 | [Number of Operations to Make Network Connected](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Operations%20to%20Make%20Network%20Connected.java)
-494 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java)
-495 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java)
-496 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java)
-497 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java)
-498 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
-499 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
-500 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
-501 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
-502 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java)
-503 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java)
-504 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
-505 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
-506 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
-507 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java)
-508 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
-509 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
-510 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
-511 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
-512 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java)
-513 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java)
-514 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
-515 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java)
-516 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
-517 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
-518 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
-519 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java)
-520 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java)
-521 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java)
-522 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
-523 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
-524 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
-525 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
-526 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java)
-527 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
-528 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
-529 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
-530 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
-531 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
-532 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
-533 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
-534 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
-535 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
-536 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
-537 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
-538 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
-539 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
-540 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java)
-541 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
-542 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java)
-543 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
-544 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
-545 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
-546 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
-547 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
-548 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
-549 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
-550 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java)
-551 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
-552 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
-553 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java)
-554 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java)
-555 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
-556 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
-557 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
-558 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
-559 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
-560 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
-561 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
-562 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
-563 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
-564 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
-565 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
-566 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java)
-567 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java)
-568 | [Rearrange Array to Maximize Prefix Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20to%20Maximize%20Prefix%20Score.java)
-569 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
-570 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java)
-571 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
-572 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
-573 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
-574 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
-575 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
-576 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java)
-577 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
-578 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
-579 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
-580 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
-581 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java)
-582 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
-583 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
-584 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
-585 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java)
-586 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
-587 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
-588 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
-589 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java)
-590 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java)
-591 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
-592 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
-593 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java)
-594 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
-595 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
-596 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java)
-597 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
-598 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
-599 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
-600 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java)
-601 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
-602 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java)
-603 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java)
-604 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
-605 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
-606 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
-607 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
-608 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
-609 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
-610 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
-611 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
-612 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java)
-613 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
-614 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java)
-615 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
-616 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
-617 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
-618 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
-619 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java)
-620 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
-621 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
-622 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
-623 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
-624 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
-625 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
-626 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
-627 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java)
-628 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
-629 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
-630 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
-631 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
-632 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
-633 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
-634 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java)
-635 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
-636 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
-637 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
-638 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java)
-639 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
-640 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
-641 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
-642 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
-643 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java)
-644 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
-645 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
-646 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
-647 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
-648 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
-649 | [Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java)
-650 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
-651 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
-652 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java)
-653 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
-654 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java)
-655 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
-656 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
-657 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
-658 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
-659 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
-660 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
-661 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java)
-662 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
-663 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
-664 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java)
-665 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
-666 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java)
-667 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
-668 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
-669 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
-670 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
-671 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
-672 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java)
-673 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
-674 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java)
-675 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java)
-676 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java)
-677 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java)
-678 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java)
-679 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
-680 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
-681 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
-682 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java)
-683 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
-684 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
-685 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
-686 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java)
-687 | [Sum Multiples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Multiples.java)
-688 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
-689 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
-690 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java)
-691 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java)
-692 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
-693 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java)
-694 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java)
-695 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
-696 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
-697 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
-698 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
-699 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
-700 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java)
-701 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
-702 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
-703 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
-704 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
-705 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
-706 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java)
-707 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
-708 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
-709 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
-710 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
-711 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
-712 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java)
-713 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
-714 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
-715 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
-716 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java)
-717 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java)
-718 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
-719 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
-720 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java)
-721 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java)
-722 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
-723 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java)
-724 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java)
-725 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
-726 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
-727 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
-728 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
-729 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
-730 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
-731 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
-732 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
-733 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
-734 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
-735 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
-736 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
-737 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
-738 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
-739 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
-740 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
-741 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java)
-742 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
-743 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
-744 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java)
-745 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
-746 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
-747 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java)
-748 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
-749 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
-750 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
-751 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java)
-752 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
-753 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
+1|[Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java)
+2|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
+3|[Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java)
+4|[First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
+5|[Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
+6|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
+7|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
+8|[Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
+9|[Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java)
+10|[Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java)
+11|[Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java)
+12|[House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
+13|[Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java)
+14|[Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
+15|[Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
+16|[Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java)
+17|[Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java)
+18|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
+19|[Minimize the Maximum Difference of Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20the%20Maximum%20Difference%20of%20Pairs.java)
+20|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
+21|[Dota2 Senate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dota2%20Senate.java)
+22|[Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
+23|[Stone Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stone%20Game%20II.java)
+24|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
+25|[Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
+26|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
+27|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java)
+28|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
+29|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
+30|[Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java)
+31|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
+32|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
+33|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
+34|[Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
+35|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
+36|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
+37|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
+38|[Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
+39|[Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
+40|[Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
+41|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
+42|[Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
+43|[Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java)
+44|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
+45|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
+46|[Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java)
+47|[Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
+48|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java)
+49|[Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java)
+50|[Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
+51|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
+52|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
+53|[Sort Linked List Already Sorted Using Absolute Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Linked%20List%20Already%20Sorted%20Using%20Absolute%20Values.java)
+54|[Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
+55|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
+56|[Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
+57|[Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
+58|[Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java)
+59|[Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java)
+60|[All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java)
+61|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java)
+62|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
+63|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
+64|[Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
+65|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
+66|[Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java)
+67|[Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java)
+68|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
+69|[Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
+70|[Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java)
+71|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
+72|[Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
+73|[Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
+74|[Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java)
+75|[Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
+76|[Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
+77|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
+78|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
+79|[Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
+80|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
+81|[Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java)
+82|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
+83|[Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
+84|[Frequency Tracker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Frequency%20Tracker.java)
+85|[Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
+86|[Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
+87|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
+88|[Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java)
+89|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
+90|[Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java)
+91|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
+92|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
+93|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
+94|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
+95|[Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java)
+96|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
+97|[Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java)
+98|[Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
+99|[Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java)
+100|[Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java)
+101|[Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
+102|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
+103|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
+104|[Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java)
+105|[Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
+106|[Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
+107|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
+108|[Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
+109|[Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
+110|[Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
+111|[Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
+112|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
+113|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
+114|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
+115|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
+116|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
+117|[Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java)
+118|[Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java)
+119|[Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java)
+120|[Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java)
+121|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
+122|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
+123|[Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
+124|[Longest Arithmetic Subsequence of Given Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence%20of%20Given%20Difference.java)
+125|[Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java)
+126|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
+127|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
+128|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
+129|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
+130|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
+131|[Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java)
+132|[Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
+133|[3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java)
+134|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
+135|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
+136|[Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
+137|[Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java)
+138|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
+139|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
+140|[Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
+141|[Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
+142|[Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
+143|[Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
+144|[Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
+145|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
+146|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java)
+147|[Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java)
+148|[Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
+149|[Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java)
+150|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
+151|[Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java)
+152|[Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
+153|[Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java)
+154|[Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
+155|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
+156|[Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java)
+157|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
+158|[Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java)
+159|[Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
+160|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
+161|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
+162|[Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java)
+163|[Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java)
+164|[Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
+165|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
+166|[Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
+167|[Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java)
+168|[Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java)
+169|[Sum in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20in%20a%20Matrix.java)
+170|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
+171|[Make String a Subsequence Using Cyclic Increments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Make%20String%20a%20Subsequence%20Using%20Cyclic%20Increments.java)
+172|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
+173|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
+174|[Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
+175|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
+176|[Minimum Flips to Make a OR b Equal to c](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Flips%20to%20Make%20a%20OR%20b%20Equal%20to%20c.java)
+177|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
+178|[Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java)
+179|[Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java)
+180|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
+181|[Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
+182|[Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
+183|[Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java)
+184|[Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
+185|[House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
+186|[Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
+187|[Check if Strings Can be Made Equal With Operations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20Strings%20Can%20be%20Made%20Equal%20With%20Operations%20II.java)
+188|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
+189|[Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
+190|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
+191|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
+192|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
+193|[Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
+194|[Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
+195|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
+196|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
+197|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
+198|[Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
+199|[Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
+200|[Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java)
+201|[Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
+202|[Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
+203|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
+204|[Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java)
+205|[Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
+206|[Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java)
+207|[Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java)
+208|[Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
+209|[Lowest Common Ancestor of a Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20II.java)
+210|[Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java)
+211|[Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java)
+212|[Insert Greatest Common Divisors in Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Greatest%20Common%20Divisors%20in%20Linked%20List.java)
+213|[Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java)
+214|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
+215|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
+216|[K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java)
+217|[Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java)
+218|[Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
+219|[Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java)
+220|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
+221|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java)
+222|[Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java)
+223|[Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
+224|[Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java)
+225|[Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java)
+226|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
+227|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
+228|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
+229|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
+230|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
+231|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
+232|[4 Keys Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Keys%20Keyboard.java)
+233|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
+234|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
+235|[Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
+236|[Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java)
+237|[Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
+238|[Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
+239|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
+240|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
+241|[Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java)
+242|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
+243|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
+244|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
+245|[Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
+246|[Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
+247|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
+248|[Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
+249|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
+250|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java)
+251|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
+252|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
+253|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
+254|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
+255|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
+256|[Maximum Sum of Almost Unique Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Almost%20Unique%20Subarray.java)
+257|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
+258|[Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
+259|[Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java)
+260|[Decoded String at Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decoded%20String%20at%20Index.java)
+261|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
+262|[Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java)
+263|[Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java)
+264|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
+265|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
+266|[Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java)
+267|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
+268|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
+269|[Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java)
+270|[Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java)
+271|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
+272|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
+273|[Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java)
+274|[Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
+275|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
+276|[Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
+277|[Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
+278|[Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java)
+279|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
+280|[Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
+281|[Minimize Maximum of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20of%20Array.java)
+282|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
+283|[Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
+284|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
+285|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
+286|[Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java)
+287|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
+288|[Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
+289|[Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
+290|[Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java)
+291|[Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java)
+292|[Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
+293|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
+294|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
+295|[Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java)
+296|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java)
+297|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
+298|[Find the Substring With Maximum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Substring%20With%20Maximum%20Cost.java)
+299|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
+300|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
+301|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
+302|[Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java)
+303|[Non-overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-overlapping%20Intervals.java)
+304|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
+305|[Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java)
+306|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
+307|[Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java)
+308|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
+309|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java)
+310|[Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
+311|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
+312|[Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
+313|[Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java)
+314|[Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java)
+315|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
+316|[Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
+317|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
+318|[Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java)
+319|[Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java)
+320|[Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
+321|[Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
+322|[Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
+323|[Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java)
+324|[Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java)
+325|[Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java)
+326|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
+327|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
+328|[Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java)
+329|[Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
+330|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
+331|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
+332|[Total Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Cost%20to%20Hire%20K%20Workers.java)
+333|[Sum Multiples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Multiples.java)
+334|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
+335|[Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
+336|[Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java)
+337|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
+338|[Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java)
+339|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
+340|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
+341|[Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
+342|[Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
+343|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
+344|[Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
+345|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
+346|[Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java)
+347|[Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java)
+348|[Find the Prefix Common Array of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Prefix%20Common%20Array%20of%20Two%20Arrays.java)
+349|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
+350|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
+351|[Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
+352|[Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
+353|[All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
+354|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
+355|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
+356|[Extra Characters in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Extra%20Characters%20in%20a%20String.java)
+357|[Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
+358|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
+359|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peak%20Index%20in%20a%20Mountain%20Array.java)
+360|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
+361|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java)
+362|[Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java)
+363|[Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java)
+364|[Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java)
+365|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
+366|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
+367|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
+368|[Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java)
+369|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
+370|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
+371|[Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
+372|[Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java)
+373|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
+374|[Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
+375|[Remove Colored Pieces if Both Neighbors are the Same Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Colored%20Pieces%20if%20Both%20Neighbors%20are%20the%20Same%20Color.java)
+376|[Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java)
+377|[Find Eventual Safe States](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Eventual%20Safe%20States.java)
+378|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
+379|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
+380|[Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
+381|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
+382|[Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java)
+383|[HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
+384|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
+385|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
+386|[Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
+387|[Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java)
+388|[Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java)
+389|[Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
+390|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
+391|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
+392|[Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
+393|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
+394|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
+395|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
+396|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
+397|[Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java)
+398|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
+399|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
+400|[Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java)
+401|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
+402|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
+403|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
+404|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
+405|[Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java)
+406|[Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
+407|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
+408|[Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
+409|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
+410|[The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
+411|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
+412|[Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
+413|[Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
+414|[Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java)
+415|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java)
+416|[Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
+417|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
+418|[Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
+419|[Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java)
+420|[Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
+421|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
+422|[Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
+423|[Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java)
+424|[Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
+425|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
+426|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
+427|[Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java)
+428|[Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
+429|[Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
+430|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
+431|[Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
+432|[Count Ways To Build Good Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Ways%20To%20Build%20Good%20Strings.java)
+433|[Minimum Score of a Path Between Two Cities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20of%20a%20Path%20Between%20Two%20Cities.java)
+434|[Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
+435|[Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
+436|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
+437|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java)
+438|[Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java)
+439|[Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
+440|[Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
+441|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java)
+442|[Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java)
+443|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
+444|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java)
+445|[4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
+446|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
+447|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
+448|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
+449|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
+450|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
+451|[Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
+452|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
+453|[Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java)
+454|[Number of Operations to Make Network Connected](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Operations%20to%20Make%20Network%20Connected.java)
+455|[Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
+456|[Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
+457|[String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java)
+458|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
+459|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
+460|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
+461|[UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java)
+462|[Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
+463|[Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
+464|[Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java)
+465|[Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java)
+466|[Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java)
+467|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
+468|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
+469|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java)
+470|[Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
+471|[Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java)
+472|[The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java)
+473|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
+474|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
+475|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
+476|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
+477|[Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java)
+478|[Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java)
+479|[Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java)
+480|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
+481|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
+482|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
+483|[Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java)
+484|[Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
+485|[Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
+486|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
+487|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
+488|[New 21 Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/New%2021%20Game.java)
+489|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
+490|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
+491|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
+492|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
+493|[Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
+494|[Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
+495|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
+496|[Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java)
+497|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
+498|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
+499|[Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
+500|[Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
+501|[Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
+502|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
+503|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
+504|[Minimum Penalty for a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Penalty%20for%20a%20Shop.java)
+505|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
+506|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
+507|[Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
+508|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
+509|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
+510|[Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java)
+511|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
+512|[Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java)
+513|[Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
+514|[Number of Subsequences That Satisfy the Given Sum Condition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subsequences%20That%20Satisfy%20the%20Given%20Sum%20Condition.java)
+515|[Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java)
+516|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
+517|[Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
+518|[Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
+519|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
+520|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
+521|[Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
+522|[Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
+523|[Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
+524|[Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
+525|[Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java)
+526|[Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
+527|[Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java)
+528|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
+529|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
+530|[Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
+531|[Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
+532|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+533|[Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java)
+534|[Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java)
+535|[Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java)
+536|[Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
+537|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java)
+538|[Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java)
+539|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
+540|[Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
+541|[Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java)
+542|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
+543|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
+544|[Longest Subarray of 1's After Deleting One Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Subarray%20of%201's%20After%20Deleting%20One%20Element.java)
+545|[Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
+546|[Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
+547|[Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java)
+548|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
+549|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
+550|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
+551|[Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
+552|[Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java)
+553|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
+554|[Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
+555|[Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java)
+556|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
+557|[The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
+558|[Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java)
+559|[Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java)
+560|[Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java)
+561|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
+562|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
+563|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
+564|[Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
+565|[Determine if a Cell Is Reachable at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20a%20Cell%20Is%20Reachable%20at%20a%20Given%20Time.java)
+566|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
+567|[Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
+568|[Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
+569|[Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
+570|[Determine the Minimum Sum of a k-avoiding Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array.java)
+571|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
+572|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
+573|[Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
+574|[Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java)
+575|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
+576|[Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java)
+577|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java)
+578|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java)
+579|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
+580|[Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
+581|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
+582|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
+583|[Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
+584|[Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java)
+585|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
+586|[Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
+587|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
+588|[Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
+589|[Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java)
+590|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
+591|[Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
+592|[Maximize the Confusion of an Exam](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Confusion%20of%20an%20Exam.java)
+593|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
+594|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
+595|[Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
+596|[Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
+597|[Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java)
+598|[Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java)
+599|[Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
+600|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
+601|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
+602|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
+603|[Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java)
+604|[Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java)
+605|[Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java)
+606|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
+607|[Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java)
+608|[Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java)
+609|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
+610|[Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java)
+611|[Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
+612|[132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java)
+613|[Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
+614|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
+615|[Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java)
+616|[Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java)
+617|[Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java)
+618|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
+619|[Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
+620|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
+621|[Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java)
+622|[Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java)
+623|[Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
+624|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
+625|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
+626|[Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java)
+627|[Maximum Value at a Given Index in a Bounded Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20at%20a%20Given%20Index%20in%20a%20Bounded%20Array.java)
+628|[Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java)
+629|[Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
+630|[Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
+631|[Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
+632|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
+633|[Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java)
+634|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
+635|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
+636|[Minimum Speed to Arrive on Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Speed%20to%20Arrive%20on%20Time.java)
+637|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
+638|[Detonate the Maximum Bombs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Detonate%20the%20Maximum%20Bombs.java)
+639|[Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
+640|[Lexicographically Smallest String After Substring Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20String%20After%20Substring%20Operation.java)
+641|[Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
+642|[Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java)
+643|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
+644|[Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java)
+645|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
+646|[Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
+647|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
+648|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
+649|[Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
+650|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
+651|[Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java)
+652|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
+653|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
+654|[Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
+655|[Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
+656|[Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java)
+657|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
+658|[The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
+659|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
+660|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
+661|[Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
+662|[Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
+663|[Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java)
+664|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
+665|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java)
+666|[Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
+667|[Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
+668|[Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
+669|[Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java)
+670|[Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java)
+671|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
+672|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
+673|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
+674|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
+675|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
+676|[Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
+677|[Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java)
+678|[Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
+679|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
+680|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
+681|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
+682|[Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java)
+683|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java)
+684|[Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
+685|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
+686|[Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java)
+687|[Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java)
+688|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
+689|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
+690|[Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java)
+691|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
+692|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
+693|[Best Time to Buy and Sell Stock with Transaction Fee](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Transaction%20Fee.java)
+694|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
+695|[Minimum Cost For Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20For%20Tickets.java)
+696|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
+697|[Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java)
+698|[Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java)
+699|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
+700|[Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java)
+701|[Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java)
+702|[Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
+703|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
+704|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
+705|[Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java)
+706|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
+707|[Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java)
+708|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
+709|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
+710|[Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java)
+711|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
+712|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
+713|[Shortest Bridge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Bridge.java)
+714|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
+715|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
+716|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
+717|[Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
+718|[Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
+719|[Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
+720|[Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
+721|[Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
+722|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
+723|[Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java)
+724|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
+725|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
+726|[Find the Maximum Divisibility Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Maximum%20Divisibility%20Score.java)
+727|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
+728|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
+729|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
+730|[Find the Score of All Prefixes of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array.java)
+731|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
+732|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
+733|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
+734|[Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
+735|[Minimum Operations to Make a Special Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20a%20Special%20Number.java)
+736|[People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
+737|[Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java)
+738|[Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java)
+739|[Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java)
+740|[Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java)
+741|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
+742|[All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
+743|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
+744|[Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java)
+745|[Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java)
+746|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
+747|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
+748|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
+749|[Solving Questions With Brainpower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solving%20Questions%20With%20Brainpower.java)
+750|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
+751|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
+752|[Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java)
+753|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md)
+754|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
+755|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
+756|[Maximum Subsequence Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subsequence%20Score.java)
+757|[Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
+758|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
+759|[Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java)
+760|[Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
+761|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
+762|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
+763|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
+764|[Find the Longest Semi-Repetitive Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Longest%20Semi-Repetitive%20Substring.java)
+765|[Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java)
+766|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
+767|[Convert an Array Into a 2D Array With Conditions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20an%20Array%20Into%20a%202D%20Array%20With%20Conditions.java)
+768|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java)
+769|[Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java)
+770|[All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java)
+771|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
+772|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
+773|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
+774|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
+775|[Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java)
+776|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
+777|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
+778|[Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
+779|[Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
+780|[Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java)
+781|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
+782|[Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
+783|[Rearrange Array to Maximize Prefix Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20to%20Maximize%20Prefix%20Score.java)
+784|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
+785|[Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java)
+786|[Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
+787|[Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java)
+788|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
+789|[Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
+790|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
+791|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
+792|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
diff --git a/README.md b/README.md
index 79190be6..4eec5fb7 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 
 Problem Category | Count
 --- | --- 
-[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 572
-[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 754
-[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 111
+[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 607
+[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 793
+[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 125
 [Concurrency](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Concurrency/README.md) | 9

From d02639a3606198ac5a1aba7715c1f392c905e102 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 6 Oct 2023 05:55:04 -0700
Subject: [PATCH 1823/2175] Create Integer Break.java

---
 Medium/Integer Break.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Integer Break.java

diff --git a/Medium/Integer Break.java b/Medium/Integer Break.java
new file mode 100644
index 00000000..10071c6f
--- /dev/null
+++ b/Medium/Integer Break.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int integerBreak(int n) {
+        if (n < 4) {
+            return n - 1;
+        }
+        int[] dp = new int[n + 1];
+        for (int i = 1; i <= 3; i++) {
+            dp[i] = i;
+        }
+        for (int i = 4; i <= n; i++) {
+            int result = i;
+            for (int j = 2; j < i; j++) {
+                result = Math.max(result, j * dp[i - j]);
+            }
+            dp[i] = result;
+        }
+        return dp[n];
+    }
+}

From 187962d20ec479ea0422d4d92bdfda7b4fefb06e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 7 Oct 2023 14:01:46 -0700
Subject: [PATCH 1824/2175] Create Build Array Where You Can Find The Maximum
 Exactly K Comparisons.java

---
 ...ind The Maximum Exactly K Comparisons.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java

diff --git a/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java b/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java
new file mode 100644
index 00000000..c7ede11f
--- /dev/null
+++ b/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java	
@@ -0,0 +1,28 @@
+class Solution {
+    
+    private static final int MOD = (int) 1000_000_007;
+
+    public int numOfArrays(int n, int m, int k) {
+        int[][][] dp = new int[n + 1][m + 1][k + 1];
+        for (int i = 0; i < dp[0].length; i++) {
+            dp[n][i][0] = 1;
+        }
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = m; j >= 0; j--) {
+                for (int l = 0; l <= k; l++) {
+                    int result = 0;
+                    for (int num = 1; num <= j; num++) {
+                        result = (result + dp[i + 1][j][l]) % MOD;
+                    }
+                    if (l > 0) {
+                        for (int num = j + 1; num <= m; num++) {
+                            result = (result + dp[i + 1][num][l - 1]) % MOD;
+                        }
+                    }
+                    dp[i][j][l] = result;
+                }
+            }
+        }
+        return dp[0][0][k];
+    }
+}

From 0c6fe309938e938744c046165ca0346040ab8588 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Oct 2023 06:54:39 -0700
Subject: [PATCH 1825/2175] Create Divisible and Non-divisible Sums
 Difference.java

---
 Easy/Divisible and Non-divisible Sums Difference.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Divisible and Non-divisible Sums Difference.java

diff --git a/Easy/Divisible and Non-divisible Sums Difference.java b/Easy/Divisible and Non-divisible Sums Difference.java
new file mode 100644
index 00000000..a9c53cc8
--- /dev/null
+++ b/Easy/Divisible and Non-divisible Sums Difference.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int differenceOfSums(int n, int m) {
+        int num1 = n * (n + 1) / 2;
+        int num2 = n / m;
+        num2 = m * num2 * (num2 + 1) / 2;
+        return num1 - 2 * num2;
+    }
+}

From 13e8601c910dc623108554635fbde041297dba80 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Oct 2023 10:05:54 -0700
Subject: [PATCH 1826/2175] Create Max Dot Product of Two Subsequences.java

---
 Hard/Max Dot Product of Two Subsequences.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Hard/Max Dot Product of Two Subsequences.java

diff --git a/Hard/Max Dot Product of Two Subsequences.java b/Hard/Max Dot Product of Two Subsequences.java
new file mode 100644
index 00000000..c2eca127
--- /dev/null
+++ b/Hard/Max Dot Product of Two Subsequences.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int maxDotProduct(int[] nums1, int[] nums2) {
+        int maxOne = Integer.MIN_VALUE;
+        int maxTwo = Integer.MIN_VALUE;
+        int minOne = Integer.MAX_VALUE;
+        int minTwo = Integer.MAX_VALUE;
+        for (int num : nums1) {
+            maxOne = Math.max(maxOne, num);
+            minOne = Math.min(minOne, num);
+        }
+        for (int num : nums2) {
+            maxTwo = Math.max(maxTwo, num);
+            minTwo = Math.min(minTwo, num);
+        }
+        if (maxOne < 0 && minTwo > 0) {
+            return maxOne * minTwo;
+        }
+        if (minOne > 0 && maxTwo < 0) {
+            return minOne * maxTwo;
+        }
+        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
+        for (int i = nums1.length - 1; i >= 0; i--) {
+            for (int j = nums2.length - 1; j >= 0; j--) {
+                int curr = nums1[i] * nums2[j] + dp[i + 1][j + 1];
+                dp[i][j] = Math.max(curr, Math.max(dp[i + 1][j], dp[i][j + 1]));
+            }
+        }
+        return dp[0][0];
+    }
+}

From de95ca123d477a4bdde503892888949c562a2872 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Oct 2023 16:29:49 -0700
Subject: [PATCH 1827/2175] Create Minimum Processing Time.java

---
 Medium/Minimum Processing Time.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Minimum Processing Time.java

diff --git a/Medium/Minimum Processing Time.java b/Medium/Minimum Processing Time.java
new file mode 100644
index 00000000..ec9b75e6
--- /dev/null
+++ b/Medium/Minimum Processing Time.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int minProcessingTime(List<Integer> processorTime, List<Integer> tasks) {
+        PriorityQueue<Integer> taskQueue = new PriorityQueue<>();
+        PriorityQueue<Integer> processorQueue = new PriorityQueue<>((a, b) -> b - a);
+        taskQueue.addAll(tasks);
+        processorQueue.addAll(processorTime);
+        int totalTime = Integer.MIN_VALUE;
+        while (!processorQueue.isEmpty()) {
+            int startTime = processorQueue.remove();
+            int currTime = Integer.MIN_VALUE;
+            for (int i = 0; i < 4; i++) {
+                currTime = Math.max(currTime, startTime + taskQueue.remove());
+            }
+            totalTime = Math.max(totalTime, currTime);
+        }
+        return totalTime;
+    }
+}

From dd344622453fdf611a2f635489f35193fd5e6676 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Oct 2023 17:05:58 -0700
Subject: [PATCH 1828/2175] Update Find First and Last Position of Element in
 Sorted Array.java

---
 ...t Position of Element in Sorted Array.java | 54 +++++++++++--------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/Medium/Find First and Last Position of Element in Sorted Array.java b/Medium/Find First and Last Position of Element in Sorted Array.java
index a61bd0dc..64e4ecec 100644
--- a/Medium/Find First and Last Position of Element in Sorted Array.java	
+++ b/Medium/Find First and Last Position of Element in Sorted Array.java	
@@ -1,27 +1,35 @@
 class Solution {
-  public int[] searchRange(int[] nums, int target) {
-    return new int[]{binarySearchHelper(nums, target, -1), binarySearchHelper(nums, target, 1)};
-  }
-  
-  private int binarySearchHelper(int[] nums, int target, int direction) {
-    int idx = -1;
-    int start = 0;
-    int end = nums.length - 1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (nums[mid] == target) {
-        idx = idx == -1 ? mid : (direction == -1 ? Math.min(mid, idx) : Math.max(mid, idx));
-        if (direction == -1) {
-          end = mid - 1;
-        } else {
-          start = mid + 1;
+
+    private static enum Position {
+        FIRST, LAST;
+    }
+
+    public int[] searchRange(int[] nums, int target) {
+        return new int[]{
+            search(nums, target, Position.FIRST),
+            search(nums, target, Position.LAST)
+        };
+    }
+
+    private static int search(int[] nums, int target, Position position) {
+        int left = 0;
+        int right = nums.length - 1;
+        int idx = -1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] == target) {
+                idx = mid;
+                if (position == Position.FIRST) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            } else if (nums[mid] > target) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
         }
-      } else if (nums[mid] > target) {
-        end = mid - 1;
-      } else {
-        start = mid + 1;
-      }
+        return idx;
     }
-    return idx;
-  }
 }

From 8fd3a652faf2825a7ce4bdcf0529ef19d8d80fa6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 9 Oct 2023 06:51:27 -0700
Subject: [PATCH 1829/2175] Create Minimum Number of Operations to Make Array
 Empty.java

---
 ...Number of Operations to Make Array Empty.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Minimum Number of Operations to Make Array Empty.java

diff --git a/Medium/Minimum Number of Operations to Make Array Empty.java b/Medium/Minimum Number of Operations to Make Array Empty.java
new file mode 100644
index 00000000..e132e463
--- /dev/null
+++ b/Medium/Minimum Number of Operations to Make Array Empty.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int minOperations(int[] nums) {
+        Map<Integer, Long> map = Arrays.stream(nums)
+        .boxed()
+        .collect(
+            Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
+        int operations = 0;
+        for (Long value : map.values()) {
+            if (value == 1) {
+                return -1;
+            }
+            operations += (int) (value / 3 + (value % 3 != 0 ? 1 : 0));
+        }
+        return operations;
+    }
+}

From fd343f2277621b311c98f1193206acda1261cd6d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 9 Oct 2023 06:51:51 -0700
Subject: [PATCH 1830/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4eec5fb7..c4fd5e63 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 1400+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1500+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count

From 5695ae7d61661d01898fa301f0243411f8d113bb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 10 Oct 2023 07:49:28 -0700
Subject: [PATCH 1831/2175] Create Minimum Number of Operations to Make Array
 Continuous.java

---
 ...f Operations to Make Array Continuous.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Hard/Minimum Number of Operations to Make Array Continuous.java

diff --git a/Hard/Minimum Number of Operations to Make Array Continuous.java b/Hard/Minimum Number of Operations to Make Array Continuous.java
new file mode 100644
index 00000000..f6f07059
--- /dev/null
+++ b/Hard/Minimum Number of Operations to Make Array Continuous.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int minOperations(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+        int[] arr = new int[set.size()];
+        int idx = 0;
+        for (Integer num : set) {
+            arr[idx++] = num;
+        }
+        Arrays.sort(arr);
+        int n = nums.length;
+        int result = n;
+        int j = 0;
+        for (int i = 0; i < arr.length; i++) {
+            while (j < arr.length && arr[j] < arr[i] + n) {
+                j++;
+            }
+            int count = j - i;
+            result = Math.min(result, n - count);
+        }
+        return result;
+    }
+}

From cecb540cf1e04614a3365e0a8c9471ffd85df1ff Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 11 Oct 2023 06:18:35 -0700
Subject: [PATCH 1832/2175] Create Number of Flowers in Full Bloom.java

---
 Hard/Number of Flowers in Full Bloom.java | 25 +++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Hard/Number of Flowers in Full Bloom.java

diff --git a/Hard/Number of Flowers in Full Bloom.java b/Hard/Number of Flowers in Full Bloom.java
new file mode 100644
index 00000000..37bb43e7
--- /dev/null
+++ b/Hard/Number of Flowers in Full Bloom.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int[] fullBloomFlowers(int[][] flowers, int[] people) {
+        int[] peopleCopy = Arrays.copyOf(people, people.length);
+        Arrays.sort(peopleCopy);
+        Arrays.sort(flowers, (a, b) -> Arrays.compare(a, b));
+        Map<Integer, Integer> map = new HashMap<>();
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        int idx = 0;
+        for (int person : peopleCopy) {
+            while (idx < flowers.length && flowers[idx][0] <= person) {
+                pq.add(flowers[idx][1]);
+                idx++;
+            }
+            while (!pq.isEmpty() && pq.peek() < person) {
+                pq.poll();
+            }
+            map.put(person, pq.size());
+        }
+        int[] result = new int[people.length];
+        for (int i = 0; i < people.length; i++) {
+            result[i] = map.get(people[i]);
+        }
+        return result;
+    }
+}

From eb05caf390f4313f3f3e494f0cea48bf8cd3e78b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 12 Oct 2023 06:34:01 -0700
Subject: [PATCH 1833/2175] Create Find in Mountain Array.java

---
 Hard/Find in Mountain Array.java | 49 ++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 Hard/Find in Mountain Array.java

diff --git a/Hard/Find in Mountain Array.java b/Hard/Find in Mountain Array.java
new file mode 100644
index 00000000..d030c247
--- /dev/null
+++ b/Hard/Find in Mountain Array.java	
@@ -0,0 +1,49 @@
+/**
+ * // This is MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface MountainArray {
+ *     public int get(int index) {}
+ *     public int length() {}
+ * }
+ */
+ 
+class Solution {
+    public int findInMountainArray(int target, MountainArray mountainArr) {
+        int n = mountainArr.length();
+        int start = 1;
+        int end = n - 2;
+        while (start != end) {
+            int mid = (start + end) / 2;
+            if (mountainArr.get(mid) < mountainArr.get(mid + 1)) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        int peakIndex = start;
+        start = 0;
+        end = peakIndex;
+        while (start != end) {
+            int mid = (start + end) / 2;
+            if (mountainArr.get(mid) < target) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        if (mountainArr.get(start) == target) {
+            return start;
+        }
+        start = peakIndex + 1;
+        end = n - 1;
+        while (start != end) {
+            int mid = (start + end) / 2;
+            if (mountainArr.get(mid) > target) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        return mountainArr.get(start) == target ? start : -1;
+    }
+}

From 8392986ad79601c12810e4cb49a07b8a86f83c4f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 13 Oct 2023 07:00:25 -0700
Subject: [PATCH 1834/2175] Update Min Cost Climbing Stairs.java

---
 Easy/Min Cost Climbing Stairs.java | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/Easy/Min Cost Climbing Stairs.java b/Easy/Min Cost Climbing Stairs.java
index 7a718918..1db8f19d 100644
--- a/Easy/Min Cost Climbing Stairs.java	
+++ b/Easy/Min Cost Climbing Stairs.java	
@@ -1,13 +1,12 @@
 class Solution {
-  public int minCostClimbingStairs(int[] cost) {
-    int n = cost.length;
-    int first = cost[0];
-    int second = cost[1];
-    for (int i = 2; i < n; i++) {
-      int curr = cost[i] + Math.min(first, second);
-      first = second;
-      second = curr;
+    public int minCostClimbingStairs(int[] cost) {
+        int stepOneCost = cost[0];
+        int stepTwoCost = cost[1];
+        for (int i = 2; i < cost.length; i++) {
+            int currCost = cost[i] + Math.min(stepOneCost, stepTwoCost);
+            stepOneCost = stepTwoCost;
+            stepTwoCost = currCost;
+        }
+        return Math.min(stepOneCost, stepTwoCost);
     }
-    return Math.min(first, second);
-  }
 }

From b4dc59fb6726a710d856b5acee27501d94085eea Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 14 Oct 2023 07:32:23 -0700
Subject: [PATCH 1835/2175] Create Painting the Walls.java

---
 Hard/Painting the Walls.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Hard/Painting the Walls.java

diff --git a/Hard/Painting the Walls.java b/Hard/Painting the Walls.java
new file mode 100644
index 00000000..ceeb36f2
--- /dev/null
+++ b/Hard/Painting the Walls.java	
@@ -0,0 +1,26 @@
+class Solution {
+
+    private static final int INVALID_VALUE = 1000_000_000;
+
+    public int paintWalls(int[] cost, int[] time) {
+        int n = cost.length;
+        Integer[][] dp = new Integer[n][n + 1];
+        return compute(0, n, cost, time, dp, n);
+    }
+
+    private int compute(int idx, int remain, int[] cost, int[] time, Integer[][] dp, int n) {
+        if (remain <= 0) {
+            return 0;
+        }
+        if (idx == n) {
+            return INVALID_VALUE;
+        }
+        if (dp[idx][remain] != null) {
+            return dp[idx][remain];
+        }
+        int paint = cost[idx] + compute(idx + 1, remain - 1 - time[idx], cost, time, dp, n);
+        int noPaint = compute(idx + 1, remain, cost, time, dp, n);
+        dp[idx][remain] = Math.min(paint, noPaint);
+        return dp[idx][remain];
+    }
+}

From 9ae580aae699a11fbe660b84e740d5002c745db5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 15 Oct 2023 10:58:54 -0700
Subject: [PATCH 1836/2175] Create  Last Visited Integers.java

---
 Easy/Last Visited Integers.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Last Visited Integers.java

diff --git a/Easy/Last Visited Integers.java b/Easy/Last Visited Integers.java
new file mode 100644
index 00000000..e6a59e34
--- /dev/null
+++ b/Easy/Last Visited Integers.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public List<Integer> lastVisitedIntegers(List<String> words) {
+        List<Integer> result = new ArrayList<>();
+        List<Integer> numbers = new ArrayList<>();
+        int cursor = -1;
+        for (String word : words) {
+            if (word.equals("prev")) {
+                result.add(cursor == -1 ? -1 : numbers.get(cursor));
+                cursor = cursor == -1 ? -1 : (cursor - 1);
+            } else {
+                numbers.add(Integer.parseInt(word));
+                cursor = numbers.size() - 1;
+            }
+        }
+        return result;
+    }
+}

From 532b766ba63b509941a680f704d5407faaf7a73d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 15 Oct 2023 16:20:01 -0700
Subject: [PATCH 1837/2175] Create Number of Ways to Stay in the Same Place
 After Some Steps.java

---
 ...ay in the Same Place After Some Steps.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Hard/Number of Ways to Stay in the Same Place After Some Steps.java

diff --git a/Hard/Number of Ways to Stay in the Same Place After Some Steps.java b/Hard/Number of Ways to Stay in the Same Place After Some Steps.java
new file mode 100644
index 00000000..a9ce7edf
--- /dev/null
+++ b/Hard/Number of Ways to Stay in the Same Place After Some Steps.java	
@@ -0,0 +1,23 @@
+class Solution {
+
+    private static final int MOD = 1000_000_007;
+
+    public int numWays(int steps, int arrLen) {
+        arrLen = Math.min(arrLen, steps);
+        int[][] dp = new int[arrLen][steps + 1];
+        dp[0][0] = 1;
+        for (int i = 1; i <= steps; i++) {
+            for (int j = arrLen - 1; j >= 0; j--) {
+                int result = dp[j][i - 1];
+                if (j > 0) {
+                    result = (result + dp[j - 1][i - 1]) % MOD;
+                }
+                if (j < arrLen - 1) {
+                    result = (result + dp[j + 1][i - 1]) % MOD;
+                }
+                dp[j][i] = result;
+            }
+        }
+        return dp[0][steps];
+    }
+}

From 183167b1f1258205128096789ab760266a9358be Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 18 Oct 2023 08:13:45 -0700
Subject: [PATCH 1838/2175] Create Parallel Courses III.java

---
 Hard/Parallel Courses III.java | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 Hard/Parallel Courses III.java

diff --git a/Hard/Parallel Courses III.java b/Hard/Parallel Courses III.java
new file mode 100644
index 00000000..f557c244
--- /dev/null
+++ b/Hard/Parallel Courses III.java	
@@ -0,0 +1,35 @@
+class Solution {
+    public int minimumTime(int n, int[][] relations, int[] time) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        int[] indegree = new int[n + 1];
+        for (int[] relation : relations) {
+            int course = relation[0];
+            int prereq = relation[1];
+            indegree[course]++;
+            map.computeIfAbsent(prereq, k -> new ArrayList<>()).add(course);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int[] maxTime = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+                maxTime[i] = time[i - 1];
+            }
+        }
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer dependent : map.getOrDefault(removed, new ArrayList<>())) {
+                maxTime[dependent] = Math.max(maxTime[dependent], maxTime[removed] + time[dependent - 1]);
+                indegree[dependent]--;
+                if (indegree[dependent] == 0) {
+                    queue.add(dependent);
+                }
+            }
+        }
+        int result = 0;
+        for (int i = 1; i <= n; i++) {
+            result = Math.max(result, maxTime[i]);
+        }
+        return result;
+    }
+}

From e7be3158b5dde10e199433f5730620621c5a7c56 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 19 Oct 2023 06:53:50 -0700
Subject: [PATCH 1839/2175] Update Backspace String Compare.java

---
 Easy/Backspace String Compare.java | 38 +++++++++++++++---------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/Easy/Backspace String Compare.java b/Easy/Backspace String Compare.java
index 170f9f69..91ef6593 100644
--- a/Easy/Backspace String Compare.java	
+++ b/Easy/Backspace String Compare.java	
@@ -1,23 +1,23 @@
 class Solution {
-  public boolean backspaceCompare(String s, String t) {
-    return formBackSpaceString(s).equals(formBackSpaceString(t));
-  }
-  
-  private String formBackSpaceString(String s) {
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-      if (c == '#') {
-        if (!stack.isEmpty()) {
-          stack.pop();
-        }
-      } else {
-        stack.push(c);
-      }
+    public boolean backspaceCompare(String s, String t) {
+        return buildBackspaceString(s).equals(buildBackspaceString(t));
     }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append(stack.pop());
+
+    private static String buildBackspaceString(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (c == '#') {
+                if (!stack.isEmpty()) {
+                    stack.pop();
+                }
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char c : stack) {
+            sb.append(c);
+        }
+        return sb.toString();
     }
-    return sb.toString();
-  }
 }

From b99d324a2f3e2153abc818c647537697ab29c603 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 20 Oct 2023 07:50:48 -0700
Subject: [PATCH 1840/2175] Update Flatten Nested List Iterator.java

---
 Medium/Flatten Nested List Iterator.java | 45 +++++++++++++-----------
 1 file changed, 24 insertions(+), 21 deletions(-)

diff --git a/Medium/Flatten Nested List Iterator.java b/Medium/Flatten Nested List Iterator.java
index 5081ee2e..087bc1ef 100644
--- a/Medium/Flatten Nested List Iterator.java	
+++ b/Medium/Flatten Nested List Iterator.java	
@@ -17,31 +17,34 @@
  */
 public class NestedIterator implements Iterator<Integer> {
 
-  private Stack<NestedInteger> stack;
-  
-  public NestedIterator(List<NestedInteger> nestedList) {
-    this.stack = new Stack<>();
-    for (int i = nestedList.size() - 1; i >= 0; i--) {
-      this.stack.push(nestedList.get(i));
+    private Stack<NestedInteger> stack;
+
+    public NestedIterator(List<NestedInteger> nestedList) {
+        this.stack = new Stack<>();
+        for (int i = nestedList.size() - 1; i >= 0; i--) {
+            this.stack.push(nestedList.get(i));
+        }
     }
-  }
 
-  @Override
-  public Integer next() {
-    int value = this.stack.pop().getInteger();
-    return value;
-  }
+    @Override
+    public Integer next() {
+        return stack.pop().getInteger();
+    }
 
-  @Override
-  public boolean hasNext() {
-    while (!this.stack.isEmpty() && !this.stack.peek().isInteger()) {
-      List<NestedInteger> ni = this.stack.pop().getList();
-      for (int i = ni.size() - 1; i >= 0; i--) {
-        this.stack.push(ni.get(i));
-      }
+    @Override
+    public boolean hasNext() {
+        while (!stack.isEmpty() && !stack.peek().isInteger()) {
+            NestedInteger popped = stack.pop();
+            if (popped == null) {
+                continue;
+            }
+            List<NestedInteger> list = popped.getList();
+            for (int i = list.size() - 1; i >= 0; i--) {
+                stack.push(list.get(i));
+            }
+        }
+        return !stack.isEmpty();
     }
-    return !this.stack.isEmpty();
-  }
 }
 
 /**

From 42b485199d6a18e16606d0dec9c89259b87d19a9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 21 Oct 2023 07:53:53 -0700
Subject: [PATCH 1841/2175] Create Constrained Subsequence Sum.java

---
 Hard/Constrained Subsequence Sum.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Hard/Constrained Subsequence Sum.java

diff --git a/Hard/Constrained Subsequence Sum.java b/Hard/Constrained Subsequence Sum.java
new file mode 100644
index 00000000..9dabd1d4
--- /dev/null
+++ b/Hard/Constrained Subsequence Sum.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int constrainedSubsetSum(int[] nums, int k) {
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> b[0] - a[0]);
+        pq.add(new int[]{nums[0], 0});
+        int result = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            while (i - pq.peek()[1] > k) {
+                pq.remove();
+            }
+            int curr = Math.max(0, pq.peek()[0]) + nums[i];
+            result = Math.max(result, curr);
+            pq.add(new int[]{curr, i});
+        }
+        return result;
+    }
+}

From de3fdc9fd167ea78df037aff9d4a914cecb3000d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 Oct 2023 08:52:06 -0700
Subject: [PATCH 1842/2175] Update Power of Four.java

---
 Easy/Power of Four.java | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/Easy/Power of Four.java b/Easy/Power of Four.java
index 18dd30c1..269c7bd7 100644
--- a/Easy/Power of Four.java	
+++ b/Easy/Power of Four.java	
@@ -1,19 +1,5 @@
 class Solution {
-  public boolean isPowerOfFour(int n) {
-    long left = 0;
-    long right = n / 2 + 1;
-    while (left <= right) {
-      long mid = (left + right) / 2;
-      long pow = (long) (Math.pow(4, mid));
-      if (pow == ((long) n)) {
-        return true;
-      }
-      if (pow > ((long) n)) {
-        right = mid - 1;
-      } else {
-        left = mid + 1;
-      }
+    public boolean isPowerOfFour(int n) {
+        return n > 0 && Math.log(n) / Math.log(2) % 2 == 0;
     }
-    return false;
-  }
 }

From e68120ea4f3f69f1fbfe6217e5cec14922e639b3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 Oct 2023 09:13:01 -0700
Subject: [PATCH 1843/2175] Create Minimum Sum of Mountain Triplets I.java

---
 Easy/Minimum Sum of Mountain Triplets I.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Minimum Sum of Mountain Triplets I.java

diff --git a/Easy/Minimum Sum of Mountain Triplets I.java b/Easy/Minimum Sum of Mountain Triplets I.java
new file mode 100644
index 00000000..cabcd870
--- /dev/null
+++ b/Easy/Minimum Sum of Mountain Triplets I.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int minimumSum(int[] nums) {
+        int n = nums.length;
+        int[] smallestRight = new int[n];
+        smallestRight[n - 1] = nums[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            smallestRight[i] = Math.min(smallestRight[i + 1], nums[i]);
+        }
+        int smallestLeft = nums[0];
+        int result = Integer.MAX_VALUE;
+        for (int i = 1; i < n; i++) {
+            if (smallestLeft < nums[i] && smallestRight[i] < nums[i]) {
+                result = Math.min(result, nums[i] + smallestRight[i] + smallestLeft);
+            }
+            smallestLeft = Math.min(smallestLeft, nums[i]);
+        }
+        return result == Integer.MAX_VALUE ? -1 : result;
+    }
+}

From c1bb0d540a29b1be62ed24675ae1bf853beace6c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 Oct 2023 17:45:13 -0700
Subject: [PATCH 1844/2175] Update Find Largest Value in Each Tree Row.java

---
 .../Find Largest Value in Each Tree Row.java  | 50 +++++++++++--------
 1 file changed, 28 insertions(+), 22 deletions(-)

diff --git a/Medium/Find Largest Value in Each Tree Row.java b/Medium/Find Largest Value in Each Tree Row.java
index 49aeca0e..2f0c7883 100644
--- a/Medium/Find Largest Value in Each Tree Row.java	
+++ b/Medium/Find Largest Value in Each Tree Row.java	
@@ -4,32 +4,38 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  public List<Integer> largestValues(TreeNode root) {
-    List<Integer> list = new ArrayList<>();
-    if (root == null) {
-      return list;
-    }
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int maxVal = Integer.MIN_VALUE;
-      int size = queue.size();
-      while (size-- > 0) {
-        TreeNode removed = queue.remove();
-        maxVal = Math.max(maxVal, removed.val);
-        if (removed.left != null) {
-          queue.add(removed.left);
+    public List<Integer> largestValues(TreeNode root) {
+        if (root == null) {
+            return new ArrayList<>();
         }
-        if (removed.right != null) {
-          queue.add(removed.right);
+        List<Integer> result = new ArrayList<>();
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            int maxValue = queue.peek().val;
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                maxValue = Math.max(maxValue, removed.val);
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            result.add(maxValue);
         }
-      }
-      list.add(maxVal);
+        return result;
     }
-    return list;
-  }
 }

From 12b5aa03214cbbb2cec061e6e36445d353f8aada Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 24 Oct 2023 16:44:22 -0700
Subject: [PATCH 1845/2175] Create Correct a Binary Tree.java

---
 Easy/Correct a Binary Tree.java | 48 +++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 Easy/Correct a Binary Tree.java

diff --git a/Easy/Correct a Binary Tree.java b/Easy/Correct a Binary Tree.java
new file mode 100644
index 00000000..3ec5f055
--- /dev/null
+++ b/Easy/Correct a Binary Tree.java	
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode correctBinaryTree(TreeNode root) {
+        Queue<Pair> queue = new LinkedList<>();
+        queue.add(new Pair(root, null));
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            Set<TreeNode> visited = new HashSet<>();
+            for (int i = 0; i < size; i++) {
+                Pair pair = queue.remove();
+                TreeNode node = pair.node();
+                TreeNode parent = pair.parent();
+                if (visited.contains(node.right)) {
+                    if (parent.left == node) {
+                        parent.left = null;
+                    } else {
+                        parent.right = null;
+                    }
+                    return root;
+                }
+                visited.add(node);
+                if (node.right != null) {
+                    queue.add(new Pair(node.right, node));
+                }
+                if (node.left != null) {
+                    queue.add(new Pair(node.left, node));
+                }
+            }
+        }
+        return root;
+    }
+
+    private static record Pair(TreeNode node, TreeNode parent) {}
+}

From 608e9a283dba926ee824e6dc0f80e0366b0f9bad Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 25 Oct 2023 08:21:11 -0700
Subject: [PATCH 1846/2175] Create K-th Symbol in Grammar.java

---
 Medium/K-th Symbol in Grammar.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/K-th Symbol in Grammar.java

diff --git a/Medium/K-th Symbol in Grammar.java b/Medium/K-th Symbol in Grammar.java
new file mode 100644
index 00000000..da370f11
--- /dev/null
+++ b/Medium/K-th Symbol in Grammar.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int kthGrammar(int n, int k) {
+        return depthFirstSearch(n, k, 0);
+    }
+
+    private int depthFirstSearch(int n, int k, int root) {
+        if (n == 1) {
+            return root;
+        }
+        int nodeCount = (int) Math.pow(2, n - 1);
+        if (k > (nodeCount / 2)) {
+            int nextRoot = (root == 0) ? 1 : 0;
+            return depthFirstSearch(n - 1, k - (nodeCount / 2), nextRoot);
+        }
+        int nextRoot = (root == 0) ? 0 : 1;
+        return depthFirstSearch(n - 1, k, nextRoot);
+    }
+}

From 0434cd9d2c7670b94a53a1c1cba42c1c3c613b59 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 30 Oct 2023 03:53:00 +0530
Subject: [PATCH 1847/2175] Create Subarrays Distinct Element Sum of Squares
 I.java

---
 ...barrays Distinct Element Sum of Squares I.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Subarrays Distinct Element Sum of Squares I.java

diff --git a/Easy/Subarrays Distinct Element Sum of Squares I.java b/Easy/Subarrays Distinct Element Sum of Squares I.java
new file mode 100644
index 00000000..fa7cee6a
--- /dev/null
+++ b/Easy/Subarrays Distinct Element Sum of Squares I.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int sumCounts(List<Integer> nums) {
+        int sum = 0;
+        int n = nums.size();
+        for (int i = 0; i < n; i++) {
+            Set<Integer> set = new HashSet<>();
+            for (int j = i; j < n; j++) {
+                set.add(nums.get(j));
+                int size = set.size();
+                sum += size * size;
+            }
+        }
+        return sum;
+    }
+}

From a7379c9bab2dab58a848e6b2239544c46227d418 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 31 Oct 2023 01:56:26 +0530
Subject: [PATCH 1848/2175] Create Find the K-or of an Array.java

---
 Easy/Find the K-or of an Array.java | 31 +++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Easy/Find the K-or of an Array.java

diff --git a/Easy/Find the K-or of an Array.java b/Easy/Find the K-or of an Array.java
new file mode 100644
index 00000000..48343d5e
--- /dev/null
+++ b/Easy/Find the K-or of an Array.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int findKOr(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            List<Integer> setBits = getSetBits(num);
+            for (Integer setBit : setBits) {
+                map.put(setBit, map.getOrDefault(setBit, 0) + 1);
+            }
+        }
+        int result = 0;
+        for (int i = 0, p = 1; i < 32; i++, p *= 2) {
+            if (map.getOrDefault(i, 0) >= k) {
+                result += p;
+            }
+        }
+        return result;
+    }
+
+    private static List<Integer> getSetBits(int num) {
+        List<Integer> bits = new ArrayList<>();
+        int bit = 0;
+        while (num > 0) {
+            if (num % 2 == 1) {
+                bits.add(bit);
+            }
+            num = num / 2;
+            bit++;
+        }
+        return bits;
+    }
+}

From 7b6bf88a2086e01e8c047c87b8e92f43a3bd8c80 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 31 Oct 2023 13:20:10 +0530
Subject: [PATCH 1849/2175] Update Find The Original Array of Prefix Xor.java

---
 .../Find The Original Array of Prefix Xor.java   | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Medium/Find The Original Array of Prefix Xor.java b/Medium/Find The Original Array of Prefix Xor.java
index 97baa6e7..46732ae1 100644
--- a/Medium/Find The Original Array of Prefix Xor.java	
+++ b/Medium/Find The Original Array of Prefix Xor.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public int[] findArray(int[] pref) {
-    int n = pref.length;
-    int[] result = new int[n];
-    result[0] = pref[0];
-    for (int i = 1; i < n; i++) {
-      result[i] = pref[i] ^ pref[i - 1];
+    public int[] findArray(int[] pref) {
+        int n = pref.length;
+        int[] result = new int[n];
+        result[0] = pref[0];
+        for (int i = 1; i < n; i++) {
+            result[i] = pref[i - 1] ^ pref[i];
+        }
+        return result;
     }
-    return result;
-  }
 }

From 76b05375450bf34319125ecf1761fa36641125b2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Nov 2023 08:16:42 +0530
Subject: [PATCH 1850/2175] Update Find Mode in Binary Search Tree.java

---
 Easy/Find Mode in Binary Search Tree.java | 83 +++++++++++++----------
 1 file changed, 46 insertions(+), 37 deletions(-)

diff --git a/Easy/Find Mode in Binary Search Tree.java b/Easy/Find Mode in Binary Search Tree.java
index a803103b..2b1f2fa0 100644
--- a/Easy/Find Mode in Binary Search Tree.java	
+++ b/Easy/Find Mode in Binary Search Tree.java	
@@ -14,44 +14,53 @@
  * }
  */
 class Solution {
-  Integer prev = null;
-  int count = 1;
-  int max = 0;
-  public int[] findMode(TreeNode root) {
-    if (root == null) {
-      return new int[0];
+    public int[] findMode(TreeNode root) {
+        ResultWrapper resultWrapper = new ResultWrapper();
+        inorder(root, resultWrapper);
+        return resultWrapper.result.stream().mapToInt(Integer::intValue).toArray();
     }
-    List<Integer> list = new ArrayList<>();
-    traverse(root, list);
-    int[] ans = new int[list.size()];
-    for (int i = 0; i < list.size(); i++) {
-      ans[i] = list.get(i);
+
+    private void inorder(TreeNode node, ResultWrapper resultWrapper) {
+        if (node == null) {
+            return;
+        }
+        inorder(node.left, resultWrapper);
+        int val = node.val;
+        resultWrapper.recordStreak(val);
+        resultWrapper.updateResult(val);
+        inorder(node.right, resultWrapper);
     }
-    return ans;
-  }
-  
-  private void traverse(TreeNode root, List<Integer> list) {
-    if (root == null) {
-      return;
+
+    private static class ResultWrapper {
+        private int maxStreak;
+        private int currStreak;
+        private Integer curr;
+        private List<Integer> result;
+
+        public ResultWrapper() {
+            this.maxStreak = 0;
+            this.currStreak = 0;
+            this.curr = 0;
+            this.result = new ArrayList<>();
+        }
+
+        public void recordStreak(int num) {
+            if (num == curr) {
+                currStreak++;
+            } else {
+                currStreak = 1;
+                curr = num;
+            }
+        }
+
+        public void updateResult(int num) {
+            if (currStreak > maxStreak) {
+                result.clear();
+                maxStreak = currStreak;
+            }
+            if (currStreak == maxStreak) {
+                result.add(num);
+            }
+        }
     }
-    traverse(root.left, list);
-    if (prev != null) {
-      if (root.val == prev) {
-        count++;
-      }
-      else {
-        count = 1;
-      }
-    }
-    if (count > max) {
-      max = count;
-      list.clear();
-      list.add(root.val);
-    }
-    else if (count == max) {
-      list.add(root.val);
-    }
-    prev = root.val;
-    traverse(root.right, list);
-  }
 }

From 220c742237aca2c665bae4307008afca94bb6a71 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 1 Nov 2023 12:40:35 +0530
Subject: [PATCH 1851/2175] Update Campus Bikes.java

---
 Medium/Campus Bikes.java | 73 ++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 40 deletions(-)

diff --git a/Medium/Campus Bikes.java b/Medium/Campus Bikes.java
index 9d385afb..129f4fbc 100644
--- a/Medium/Campus Bikes.java	
+++ b/Medium/Campus Bikes.java	
@@ -1,46 +1,39 @@
 class Solution {
-  public int[] assignBikes(int[][] workers, int[][] bikes) {
-    PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>(){
-      public int compare(Node n1, Node n2) {
-        int c = n1.dist - n2.dist;
-        if (c != 0) {
-          return c;
+    public int[] assignBikes(int[][] workers, int[][] bikes) {
+        int workerCount = workers.length;
+        int bikeCount = bikes.length;
+        PriorityQueue<WorkerBikePair> priorityQueue = new PriorityQueue<>();
+        for (int i = 0; i < workerCount; i++) {
+            for (int j = 0; j < bikeCount; j++) {
+                priorityQueue.add(new WorkerBikePair(manhattanDistance(workers[i], bikes[j]), i, j));
+            }
         }
-        c = n1.workIdx - n2.workIdx;
-        return c != 0 ? c : n1.cycleIdx - n2.cycleIdx;
-      }
-    });
-    for (int i = 0; i < workers.length; i++) {
-      for (int j = 0; j < bikes.length; j++) {
-        pq.add(new Node(getDist(workers[i], bikes[j]), i, j));
-      }
+        Set<Integer> bikeDone = new HashSet<>();
+        int[] result = new int[workerCount];
+        Arrays.fill(result, Integer.MIN_VALUE);
+        while (!priorityQueue.isEmpty()) {
+            WorkerBikePair removed = priorityQueue.remove();
+            if (result[removed.workerIdx] == Integer.MIN_VALUE && !bikeDone.contains(removed.bikeIdx)) {
+                result[removed.workerIdx] = removed.bikeIdx;
+                bikeDone.add(removed.bikeIdx);
+            }
+        }
+        return result;
     }
-    int[] ans = new int[workers.length];
-    boolean[] bikesTaken = new boolean[bikes.length];
-    Arrays.fill(ans, Integer.MIN_VALUE);
-    while (!pq.isEmpty()) {
-      Node node = pq.remove();
-      if (ans[node.workIdx] == Integer.MIN_VALUE && !bikesTaken[node.cycleIdx]) {
-        ans[node.workIdx] = node.cycleIdx;
-        bikesTaken[node.cycleIdx] = true;
-      }
+
+    private record WorkerBikePair(int manhattanDistance, int workerIdx, int bikeIdx) implements Comparable<WorkerBikePair> {
+        @Override
+        public int compareTo(WorkerBikePair o) {
+            int c = manhattanDistance - o.manhattanDistance;
+            if (c != 0) {
+                return c;
+            }
+            c = workerIdx - o.workerIdx;
+            return c != 0 ? c : bikeIdx - o.bikeIdx;
+        }
     }
-    return ans;
-  }
-  
-  private int getDist(int[] p1, int[] p2) {
-    return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
-  }
-}
 
-class Node {
-  int dist;
-  int workIdx;
-  int cycleIdx;
-  
-  public Node(int dist, int workIdx, int cycleIdx) {
-    this.dist = dist;
-    this.workIdx = workIdx;
-    this.cycleIdx = cycleIdx;
-  }
+    private static int manhattanDistance(int[] p1, int[] p2) {
+        return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
+    }
 }

From 02b74a08449884c1e9aa374fea854256b34bbe8a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 2 Nov 2023 11:48:18 +0530
Subject: [PATCH 1852/2175] Update Count Nodes Equal to Average of Subtree.java

---
 ...unt Nodes Equal to Average of Subtree.java | 35 +++++++++----------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git a/Medium/Count Nodes Equal to Average of Subtree.java b/Medium/Count Nodes Equal to Average of Subtree.java
index a642fc31..5a6d2d75 100644
--- a/Medium/Count Nodes Equal to Average of Subtree.java	
+++ b/Medium/Count Nodes Equal to Average of Subtree.java	
@@ -14,24 +14,23 @@
  * }
  */
 class Solution {
-  public int averageOfSubtree(TreeNode root) {
-    int[] result = {0};
-    helper(root, result);
-    return result[0];
-  }
-  
-  private int[] helper(TreeNode root, int[] result) {
-    if (root == null) {
-      return new int[]{0, 0};
+    public int averageOfSubtree(TreeNode root) {
+        int[] result = {0};
+        recurse(root, result);
+        return result[0];
     }
-    int[] left = helper(root.left, result);
-    int[] right = helper(root.right, result);
-    int sum = left[0] + right[0] + root.val;
-    int numOfNodes = left[1] + right[1] + 1;
-    int average = sum / numOfNodes;
-    if (root.val == average) {
-      result[0]++;
+
+    private int[] recurse(TreeNode root, int[] result) {
+        if (root == null) {
+            return new int[]{0, 0};
+        }
+        int[] left = recurse(root.left, result);
+        int[] right = recurse(root.right, result);
+        int sum = left[0] + right[0] + root.val;
+        int count = left[1] + right[1] + 1;
+        if (count != 0 && sum / count == root.val) {
+            result[0]++;
+        }
+        return new int[]{sum, count};
     }
-    return new int[]{sum, numOfNodes};
-  }
 }

From c69da4fea5e461e849a4361d44a5cdc80e9d24e5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 3 Nov 2023 11:02:37 +0530
Subject: [PATCH 1853/2175] Update and rename Build an Array With Stack
 Operations.java to Build an Array With Stack Operations.java

---
 .../Build an Array With Stack Operations.java | 20 ----------------
 .../Build an Array With Stack Operations.java | 23 +++++++++++++++++++
 2 files changed, 23 insertions(+), 20 deletions(-)
 delete mode 100644 Easy/Build an Array With Stack Operations.java
 create mode 100644 Medium/Build an Array With Stack Operations.java

diff --git a/Easy/Build an Array With Stack Operations.java b/Easy/Build an Array With Stack Operations.java
deleted file mode 100644
index c3a57156..00000000
--- a/Easy/Build an Array With Stack Operations.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-  public List<String> buildArray(int[] target, int n) {
-    List<String> ans = new ArrayList<>();
-    final String PUSH = "Push";
-    final String POP = "Pop";
-    int idx = 0;
-    int curr = 1;
-    while (idx < target.length) {
-      ans.add(PUSH);
-      if (target[idx] == curr) {
-        idx++;
-      }
-      else {
-        ans.add(POP);
-      }
-      curr++;
-    }
-    return ans;
-  }
-}
diff --git a/Medium/Build an Array With Stack Operations.java b/Medium/Build an Array With Stack Operations.java
new file mode 100644
index 00000000..f36177cd
--- /dev/null
+++ b/Medium/Build an Array With Stack Operations.java	
@@ -0,0 +1,23 @@
+class Solution {
+
+    private static final String PUSH = "Push";
+    private static final String POP = "Pop";
+
+    public List<String> buildArray(int[] target, int n) {
+        int idx = 0;
+        List<String> result = new ArrayList<>();
+        for (int i = 1; i <= n; i++) {
+            if (target[idx] == i) {
+                idx++;
+                result.add(PUSH);
+            } else {
+                result.add(PUSH);
+                result.add(POP);
+            }
+            if (idx == target.length) {
+                break;
+            }
+        }
+        return result;
+    }
+}

From 08d5d21f043018b65b0d55daac6349464b930e2e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 Nov 2023 03:19:02 +0530
Subject: [PATCH 1854/2175] Update Last Moment Before All Ants Fall Out of a
 Plank.java

---
 ...nt Before All Ants Fall Out of a Plank.java | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Medium/Last Moment Before All Ants Fall Out of a Plank.java b/Medium/Last Moment Before All Ants Fall Out of a Plank.java
index 45e59801..e061b5d3 100644
--- a/Medium/Last Moment Before All Ants Fall Out of a Plank.java	
+++ b/Medium/Last Moment Before All Ants Fall Out of a Plank.java	
@@ -1,12 +1,12 @@
 class Solution {
-  public int getLastMoment(int n, int[] left, int[] right) {
-    int res = 0;
-    for (int ant : left) {
-      res = Math.max(res, ant);
+    public int getLastMoment(int n, int[] left, int[] right) {
+        int result = 0;
+        for (int num : left) {
+            result = Math.max(result, num);
+        }
+        for (int num : right) {
+            result = Math.max(result, n - num);
+        }
+        return result;
     }
-    for (int ant : right) {
-      res = Math.max(res, n - ant);
-    }
-    return res;
-  }
 }

From bcc80bf2250a3f7fb145217ee8ed802e520e8ce2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Nov 2023 05:46:39 +0530
Subject: [PATCH 1855/2175] Update Seat Reservation Manager.java

---
 Medium/Seat Reservation Manager.java | 30 +++++++++++++---------------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/Medium/Seat Reservation Manager.java b/Medium/Seat Reservation Manager.java
index d8825a61..8a7e8edb 100644
--- a/Medium/Seat Reservation Manager.java	
+++ b/Medium/Seat Reservation Manager.java	
@@ -1,23 +1,21 @@
 class SeatManager {
 
-  PriorityQueue<Integer> pq;
-  int count;
+    private PriorityQueue<Integer> seats;
 
-  public SeatManager(int n) {
-    pq = new PriorityQueue<>();
-    count = 1;
-  }
-
-  public int reserve() {
-    if (pq.size() == 0) {
-      return count++;
+    public SeatManager(int n) {
+        this.seats = new PriorityQueue<>();
+        for (int i = 1; i <= n; i++) {
+            this.seats.add(i);
+        }
+    }
+    
+    public int reserve() {
+        return this.seats.poll();
+    }
+    
+    public void unreserve(int seatNumber) {
+        this.seats.add(seatNumber);
     }
-    return pq.remove();
-  }
-
-  public void unreserve(int seatNumber) {
-    pq.add(seatNumber);
-  }
 }
 
 /**

From e0b6989d09021e36d274925ae31919ca8f70640d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 8 Nov 2023 10:07:21 +0530
Subject: [PATCH 1856/2175] Update Find the Winner of an Array Game.java

---
 Medium/Find the Winner of an Array Game.java | 27 ++++++++++----------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/Medium/Find the Winner of an Array Game.java b/Medium/Find the Winner of an Array Game.java
index 0c7130f4..98932a1e 100644
--- a/Medium/Find the Winner of an Array Game.java	
+++ b/Medium/Find the Winner of an Array Game.java	
@@ -1,17 +1,16 @@
 class Solution {
-  public int getWinner(int[] arr, int k) {
-    int currentElement = arr[0];
-    int n = arr.length;
-    int currentWinCount = 0;
-    for (int i = 1; i < n; i++) {
-      if (arr[i] > currentElement) {
-        currentElement = arr[i];
-        currentWinCount = 0;
-      }
-      if (++currentWinCount == k) {
-        break;
-      }
+    public int getWinner(int[] arr, int k) {
+        int curr = arr[0];
+        int streak = 0;
+        for (int i = 1; i < arr.length; i++) {
+            if (curr < arr[i]) {
+                curr = arr[i];
+                streak = 0;
+            } 
+            if (++streak == k) {
+                break;
+            }
+        }
+        return curr;
     }
-    return currentElement;
-  }
 }

From 704e7c9009d0a806530dbbb6a563f3a769cf69eb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 Nov 2023 06:27:23 +0530
Subject: [PATCH 1857/2175] Update Count Number of Homogenous Substrings.java

---
 ...Count Number of Homogenous Substrings.java | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/Medium/Count Number of Homogenous Substrings.java b/Medium/Count Number of Homogenous Substrings.java
index 64dd8610..4a543690 100644
--- a/Medium/Count Number of Homogenous Substrings.java	
+++ b/Medium/Count Number of Homogenous Substrings.java	
@@ -1,18 +1,18 @@
 class Solution {
-  private final int MOD = 1000000007;
-  public int countHomogenous(String s) {
-    int count = 0;
-    int start = 0;
-    int end = 0;
-    int n = s.length();
-    while (end < n) {
-      if (s.charAt(start) == s.charAt(end)) {
-        count = (count + (end - start + 1)) % MOD;
-        end++;
-      } else {
-        start++;
-      }
+
+    private static final int MOD = 1_000_000_007;
+
+    public int countHomogenous(String s) {
+        int result = 0;
+        int streak = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (i == 0 || s.charAt(i) == s.charAt(i - 1)) {
+                streak++;
+            } else {
+                streak = 1;
+            }
+            result = (result + streak) % MOD;
+        }
+        return result;
     }
-    return count;
-  }
 }

From 0878cdcb6c23c7231b892eec6c24ba8b51186ccc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 10 Nov 2023 06:36:35 +0530
Subject: [PATCH 1858/2175] Update Restore the Array From Adjacent Pairs.java

---
 ...Restore the Array From Adjacent Pairs.java | 50 +++++++++++--------
 1 file changed, 28 insertions(+), 22 deletions(-)

diff --git a/Medium/Restore the Array From Adjacent Pairs.java b/Medium/Restore the Array From Adjacent Pairs.java
index bbe2461c..041f727d 100644
--- a/Medium/Restore the Array From Adjacent Pairs.java	
+++ b/Medium/Restore the Array From Adjacent Pairs.java	
@@ -1,25 +1,31 @@
 class Solution {
-  public int[] restoreArray(int[][] adjacentPairs) {
-    Map<Integer, List<Integer>> map = new HashMap<>();
-    for (int[] pair : adjacentPairs) {
-      map.computeIfAbsent(pair[0], k -> new ArrayList<>()).add(pair[1]);
-      map.computeIfAbsent(pair[1], k -> new ArrayList<>()).add(pair[0]);
+    public int[] restoreArray(int[][] adjacentPairs) {
+        int n = adjacentPairs.length + 1;
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int[] pair : adjacentPairs) {
+            map.computeIfAbsent(pair[0], k -> new ArrayList<>()).add(pair[1]);
+            map.computeIfAbsent(pair[1], k -> new ArrayList<>()).add(pair[0]);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int firstElement = map.entrySet()
+                .stream()
+                .filter(entry -> entry.getValue().size() == 1)
+                .map(Map.Entry::getKey)
+                .findFirst()
+                .orElse(-1);
+        queue.add(firstElement);
+        Set<Integer> set = new HashSet<>();
+        int[] result = new int[n];
+        int idx = 0;
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            if (set.contains(removed)) {
+                continue;
+            }
+            result[idx++] = removed;
+            set.add(removed);
+            queue.addAll(map.get(removed));
+        }
+        return result;
     }
-    int head = map.keySet().stream().filter(k -> map.get(k).size() == 1).findFirst().orElse(-1);
-    Set<Integer> visited = new HashSet<>();
-    int[] result = new int[map.size()];
-    int idx = 0;
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(head);
-    while (!queue.isEmpty()) {
-      int removed = queue.remove();
-      if (visited.contains(removed)) {
-        continue;
-      }
-      result[idx++] = removed;
-      visited.add(removed);
-      queue.addAll(map.get(removed));
-    }
-    return result;
-  }
 }

From 4bda99c789c57ba49d280c245e92bd9e8491010e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 10 Nov 2023 19:42:56 +0530
Subject: [PATCH 1859/2175] Create Find Champion I.java

---
 Easy/Find Champion I.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Find Champion I.java

diff --git a/Easy/Find Champion I.java b/Easy/Find Champion I.java
new file mode 100644
index 00000000..4728f452
--- /dev/null
+++ b/Easy/Find Champion I.java	
@@ -0,0 +1,20 @@
+import java.util.Map.Entry;
+
+class Solution {
+    public int findChampion(int[][] grid) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1) {
+                    map.put(i, map.getOrDefault(i, 0) + 1);
+                }
+            }
+        }
+        return map.entrySet()
+            .stream()
+            .filter(entry -> entry.getValue() == grid.length - 1)
+            .findFirst()
+            .map(Entry::getKey)
+            .orElse(-1);
+    }
+}

From f8c730eaa2d92aa3892fe312c732678043b99383 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 11 Nov 2023 07:19:09 +0530
Subject: [PATCH 1860/2175] Create Design Graph With Shortest Path
 Calculator.java

---
 ...n Graph With Shortest Path Calculator.java | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 Hard/Design Graph With Shortest Path Calculator.java

diff --git a/Hard/Design Graph With Shortest Path Calculator.java b/Hard/Design Graph With Shortest Path Calculator.java
new file mode 100644
index 00000000..0b7fddf1
--- /dev/null
+++ b/Hard/Design Graph With Shortest Path Calculator.java	
@@ -0,0 +1,43 @@
+class Graph {
+
+    private final Map<Integer, List<Connection>> graph;
+
+    public Graph(int n, int[][] edges) {
+        this.graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], edge[2]));
+        }
+    }
+
+    public void addEdge(int[] edge) {
+        graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], edge[2]));
+    }
+
+    public int shortestPath(int node1, int node2) {
+        PriorityQueue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
+        queue.add(new int[]{node1, 0});
+        Set<Integer> seen = new HashSet<>();
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int node = removed[0];
+            if (node == node2) {
+                return removed[1];
+            }
+            if (graph.containsKey(node) && seen.add(node)) {
+                for (Connection connection : graph.getOrDefault(removed[0], new ArrayList<>())) {
+                    queue.add(new int[]{connection.node, removed[1] + connection.cost});
+                }
+            }
+        }
+        return -1;
+    }
+
+    private record Connection(int node, int cost) { }
+}
+
+/**
+ * Your Graph object will be instantiated and called as such:
+ * Graph obj = new Graph(n, edges);
+ * obj.addEdge(edge);
+ * int param_2 = obj.shortestPath(node1,node2);
+ */

From 61a865c37425617198cb1a4e91b0c3d7f9fa0dd9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Nov 2023 07:09:41 +0530
Subject: [PATCH 1861/2175] Create Bus Routes.java

---
 Hard/Bus Routes.java | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Hard/Bus Routes.java

diff --git a/Hard/Bus Routes.java b/Hard/Bus Routes.java
new file mode 100644
index 00000000..54c2762a
--- /dev/null
+++ b/Hard/Bus Routes.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public int numBusesToDestination(int[][] routes, int source, int target) {
+        if (source == target) {
+            return 0;
+        }
+        Map<Integer, Set<Integer>> stopToBusMapping = new HashMap<>();
+        for (int i = 0; i < routes.length; i++) {
+            for (int stop : routes[i]) {
+                stopToBusMapping.computeIfAbsent(stop, k -> new HashSet<>()).add(i);
+            }
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        Set<Integer> visited = new HashSet<>();
+        for (int route : stopToBusMapping.get(source)) {
+            queue.add(route);
+            visited.add(route);
+        }
+        int buses = 1;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                for (int stop : routes[removed]) {
+                    if (stop == target) {
+                        return buses;
+                    }
+                    for (int nextBus : stopToBusMapping.getOrDefault(stop, new HashSet<>())) {
+                        if (!visited.contains(nextBus)) {
+                            visited.add(nextBus);
+                            queue.add(nextBus);
+                        }
+                    }
+                }
+            }
+            buses++;
+        }
+        return -1;
+    }
+}

From e330385ad3ecff0a0af968108b5e2f2c914188b6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 Nov 2023 09:37:03 +0530
Subject: [PATCH 1862/2175] Create High-Access Employees.java

---
 Medium/High-Access Employees.java | 43 +++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 Medium/High-Access Employees.java

diff --git a/Medium/High-Access Employees.java b/Medium/High-Access Employees.java
new file mode 100644
index 00000000..8c881fc8
--- /dev/null
+++ b/Medium/High-Access Employees.java	
@@ -0,0 +1,43 @@
+class Solution {
+    public List<String> findHighAccessEmployees(List<List<String>> accessTimeEntries) {
+        Map<String, List<TimeRecord>> map = new HashMap<>();
+        for (List<String> entry : accessTimeEntries) {
+            String employee = entry.get(0);
+            String time = entry.get(1);
+            map.computeIfAbsent(employee, k -> new ArrayList<>()).add(TimeRecord.buildTimeRecord(time));
+        }
+        List<String> result = new ArrayList<>();
+        for (String key : map.keySet()) {
+            List<TimeRecord> entries = map.get(key);
+            if (entries.size() < 3) {
+                continue;
+            }
+            Collections.sort(entries);
+            for (int i = 0; i < entries.size() - 2; i++) {
+                if (TimeRecord.areWithinSameHour(entries.get(i), entries.get(i + 2))) {
+                    result.add(key);
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
+    private record TimeRecord(int totalMinutes) implements Comparable<TimeRecord> {
+
+        public static TimeRecord buildTimeRecord(String entry) {
+            int hour = Integer.parseInt(entry.substring(0, 2));
+            int min = Integer.parseInt(entry.substring(2));
+            return new TimeRecord(hour * 60 + min);
+        }
+
+        public static boolean areWithinSameHour(TimeRecord startTime, TimeRecord endTime) {
+            return endTime.totalMinutes - startTime.totalMinutes < 60;
+        }
+
+        @Override
+        public int compareTo(TimeRecord o) {
+            return this.totalMinutes - o.totalMinutes;
+        }
+    }
+}

From 9e4fc67c04fb3ccdced7fd70f8666fdce7b2ef2b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 20 Nov 2023 15:19:10 +0530
Subject: [PATCH 1863/2175] Update Minimum Amount of Time to Collect
 Garbage.java

---
 ...mum Amount of Time to Collect Garbage.java | 49 ++++++++-----------
 1 file changed, 20 insertions(+), 29 deletions(-)

diff --git a/Medium/Minimum Amount of Time to Collect Garbage.java b/Medium/Minimum Amount of Time to Collect Garbage.java
index b0ac91ff..ace2125d 100644
--- a/Medium/Minimum Amount of Time to Collect Garbage.java	
+++ b/Medium/Minimum Amount of Time to Collect Garbage.java	
@@ -1,34 +1,25 @@
 class Solution {
-  public int garbageCollection(String[] garbage, int[] travel) {
-    int[] lastIdx = {-1, -1, -1};
-    Map<Integer, int[]> garbageCount = new HashMap<>();
-    for (int i = 0; i < garbage.length; i++) {
-      garbageCount.put(i, new int[3]);
-      for (char c : garbage[i].toCharArray()) {
-        if (c == 'M') {
-          lastIdx[0] = i;
-          garbageCount.get(i)[0]++;
+    public int garbageCollection(String[] garbage, int[] travel) {
+        Map<Character, Integer> lastIdx = new HashMap<>();
+        for (int i = garbage.length - 1; i >= 0; i--) {
+            if (garbage[i].indexOf('M') != -1) {
+                lastIdx.putIfAbsent('M', i);
+            }
+            if (garbage[i].indexOf('G') != -1) {
+                lastIdx.putIfAbsent('G', i);
+            }
+            if (garbage[i].indexOf('P') != -1) {
+                lastIdx.putIfAbsent('P', i);
+            }
         }
-        if (c == 'P') {
-          lastIdx[1] = i;
-          garbageCount.get(i)[1]++;
+        int totalTime = 0;
+        for (int i = 0; i < garbage.length; i++) {
+            int travelTime = i == 0 ? 0 : travel[i - 1];
+            totalTime += garbage[i].length();
+            totalTime += lastIdx.getOrDefault('P', -1) >= i ? travelTime : 0;
+            totalTime += lastIdx.getOrDefault('M', -1) >= i ? travelTime : 0;
+            totalTime += lastIdx.getOrDefault('G', -1) >= i ? travelTime : 0;
         }
-        if (c == 'G') {
-          lastIdx[2] = i;
-          garbageCount.get(i)[2]++;
-        }
-      }
-    }
-    int time = 0;
-    for (int i = 0; i < 3; i++) {
-      for (int j = 0; j < garbage.length; j++) {
-        if (lastIdx[i] < j) {
-          break;
-        }
-        time += j == 0 ? 0 : travel[j - 1];
-        time += garbageCount.get(j)[i];
-      }
+        return totalTime;
     }
-    return time;
-  }
 }

From 8914d77227edd07ce15f6ba127c62c56064b5df9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 21 Nov 2023 16:12:26 +0530
Subject: [PATCH 1864/2175] Create Make Three Strings Equal.java

---
 Easy/Make Three Strings Equal.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Make Three Strings Equal.java

diff --git a/Easy/Make Three Strings Equal.java b/Easy/Make Three Strings Equal.java
new file mode 100644
index 00000000..a1e7477f
--- /dev/null
+++ b/Easy/Make Three Strings Equal.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int findMinimumOperations(String s1, String s2, String s3) {
+        int idx = 0;
+        while (idx < s1.length() && idx < s2.length() && idx < s3.length() && 
+               s1.charAt(idx) == s2.charAt(idx) && s1.charAt(idx) == s3.charAt(idx)) {
+            idx++;
+        }
+        if (idx == 0) {
+            return -1;
+        }
+        return s1.length() + s2.length() + s3.length() - 3 * idx;
+    }
+}

From 25c398f7c1ed198fcc31255e01f170c7122c60a8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Nov 2023 12:01:35 -0800
Subject: [PATCH 1865/2175] Create Find Words Containing Character.java

---
 Easy/Find Words Containing Character.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Find Words Containing Character.java

diff --git a/Easy/Find Words Containing Character.java b/Easy/Find Words Containing Character.java
new file mode 100644
index 00000000..ba268c41
--- /dev/null
+++ b/Easy/Find Words Containing Character.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public List<Integer> findWordsContaining(String[] words, char x) {
+        return IntStream.range(0, words.length)
+            .filter(i -> words[i].indexOf(x) != -1)
+            .boxed()
+            .collect(Collectors.toList());
+    }
+}

From 36dc3534b788bf76b2737914790b9ee9b39d1713 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 27 Nov 2023 03:42:23 -0800
Subject: [PATCH 1866/2175] Create Matrix Similarity After Cyclic Shifts.java

---
 Easy/Matrix Similarity After Cyclic Shifts.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Matrix Similarity After Cyclic Shifts.java

diff --git a/Easy/Matrix Similarity After Cyclic Shifts.java b/Easy/Matrix Similarity After Cyclic Shifts.java
new file mode 100644
index 00000000..624bcf08
--- /dev/null
+++ b/Easy/Matrix Similarity After Cyclic Shifts.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public boolean areSimilar(int[][] mat, int k) {
+        for (int j = 0; j < mat.length; j++) {
+            if (j % 2 != 0) {
+                continue;
+            }
+            int[] row = mat[j];
+            int n = row.length;
+            for (int i = 0; i < n; i++) {
+                if (row[i] != row[(i + k) % n]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

From ed44c4e4543e05065d3f0bde106af011d5a05ea2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 1 Dec 2023 14:44:04 -0800
Subject: [PATCH 1867/2175] Update Check If Two String Arrays are
 Equivalent.java

---
 ...k If Two String Arrays are Equivalent.java | 43 +++++++++----------
 1 file changed, 20 insertions(+), 23 deletions(-)

diff --git a/Easy/Check If Two String Arrays are Equivalent.java b/Easy/Check If Two String Arrays are Equivalent.java
index 70a73e1a..880301c2 100644
--- a/Easy/Check If Two String Arrays are Equivalent.java	
+++ b/Easy/Check If Two String Arrays are Equivalent.java	
@@ -1,27 +1,24 @@
 class Solution {
-  public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
-    int wordIdxOne = 0;
-    int wordIdxTwo = 0;
-    int idxOne = 0;
-    int idxTwo = 0;
-    while (wordIdxOne < word1.length && wordIdxTwo < word2.length) {
-      if (idxOne == word1[wordIdxOne].length() || idxTwo == word2[wordIdxTwo].length()) {
-        if (idxOne == word1[wordIdxOne].length()) {
-          wordIdxOne++;
-          idxOne = 0;
+    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
+        int idxOne = 0;
+        int idxTwo = 0;
+        int wordIdxOne = 0;
+        int wordIdxTwo = 0;
+        while (idxOne < word1.length && idxTwo < word2.length) {
+            if (word1[idxOne].charAt(wordIdxOne) != word2[idxTwo].charAt(wordIdxTwo)) {
+                return false;
+            }
+            wordIdxOne++;
+            wordIdxTwo++;
+            if (wordIdxOne == word1[idxOne].length()) {
+                wordIdxOne = 0;
+                idxOne++;
+            }
+            if (wordIdxTwo == word2[idxTwo].length()) {
+                wordIdxTwo = 0;
+                idxTwo++;
+            }
         }
-        if (idxTwo == word2[wordIdxTwo].length()) {
-          wordIdxTwo++;
-          idxTwo = 0;
-        }
-      } else {
-        if (word1[wordIdxOne].charAt(idxOne) != word2[wordIdxTwo].charAt(idxTwo)) {
-          return false;
-        }
-        idxOne++;
-        idxTwo++;
-      }
+        return idxOne == word1.length && idxTwo == word2.length;
     }
-    return wordIdxOne == word1.length && wordIdxTwo == word2.length;
-  }
 }

From 25e2990898b09abcbcaf3dd3ba7e2a40d9cac394 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Dec 2023 11:08:00 -0800
Subject: [PATCH 1868/2175] Update Find Words That Can Be Formed by
 Characters.java

---
 ...ords That Can Be Formed by Characters.java | 43 +++++++++----------
 1 file changed, 20 insertions(+), 23 deletions(-)

diff --git a/Easy/Find Words That Can Be Formed by Characters.java b/Easy/Find Words That Can Be Formed by Characters.java
index 1dce1552..23550740 100644
--- a/Easy/Find Words That Can Be Formed by Characters.java	
+++ b/Easy/Find Words That Can Be Formed by Characters.java	
@@ -1,27 +1,24 @@
 class Solution {
-  public int countCharacters(String[] words, String chars) {
-    Map<Character, Integer> frequency = getFrequencyMap(chars);
-    return Arrays.stream(words)
-      .filter(word -> canBeFormed(word, frequency))
-      .map(word -> word.length())
-      .reduce(0, Integer::sum);
-  }
-  
-  private boolean canBeFormed(String word, Map<Character, Integer> frequency) {
-    Map<Character, Integer> wordFrequency = getFrequencyMap(word);
-    for (Character key : wordFrequency.keySet()) {
-      if (frequency.getOrDefault(key, 0) < wordFrequency.get(key)) {
-        return false;
-      }
+    public int countCharacters(String[] words, String chars) {
+        Map<Character, Long> targetMap = buildFrequencyMap(chars);
+        return Arrays.stream(words)
+                .filter(word -> doesIntersect(buildFrequencyMap(word), targetMap))
+                .mapToInt(String::length)
+                .sum();
     }
-    return true;
-  }
-  
-  private Map<Character, Integer> getFrequencyMap(String s) {
-    Map<Character, Integer> frequency = new HashMap<>();
-    for (char c : s.toCharArray()) {
-      frequency.put(c, frequency.getOrDefault(c, 0) + 1);
+
+    private static boolean doesIntersect(Map<Character, Long> currMap, Map<Character, Long> targetMap) {
+        for (Character key : currMap.keySet()) {
+            if (targetMap.getOrDefault(key, 0L) < currMap.get(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static Map<Character, Long> buildFrequencyMap(String s) {
+        return s.chars()
+                .mapToObj(c -> (char) c)
+                .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
     }
-    return frequency;
-  }
 }

From 9c60e43d7b6899b24275415833d32bb18997e1a4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Dec 2023 08:30:56 -0800
Subject: [PATCH 1869/2175] Create Find the Peaks.java

---
 Easy/Find the Peaks.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Find the Peaks.java

diff --git a/Easy/Find the Peaks.java b/Easy/Find the Peaks.java
new file mode 100644
index 00000000..f6120cd5
--- /dev/null
+++ b/Easy/Find the Peaks.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public List<Integer> findPeaks(int[] mountain) {
+        List<Integer> result = new ArrayList<>();
+        for (int i = 1; i < mountain.length - 1; i++) {
+            if (mountain[i] > mountain[i - 1] && mountain[i] > mountain[i + 1]) {
+                result.add(i);
+            }
+        }
+        return result;
+    }
+}

From f52aafa642c12afd1446f7aa5e3626af9138779c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Dec 2023 11:56:24 -0800
Subject: [PATCH 1870/2175] Create Count Complete Substrings.java

---
 Medium/Count Complete Substrings.java | 54 +++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 Medium/Count Complete Substrings.java

diff --git a/Medium/Count Complete Substrings.java b/Medium/Count Complete Substrings.java
new file mode 100644
index 00000000..995cf4b0
--- /dev/null
+++ b/Medium/Count Complete Substrings.java	
@@ -0,0 +1,54 @@
+class Solution {
+    public int countCompleteSubstrings(String word, int k) {
+        int count = 0;
+        StringBuilder sb = new StringBuilder();
+        int n = word.length();
+        for (int i = 0; i < n; i++) {
+            sb.append(word.charAt(i));
+            if (i < n - 1 && Math.abs(word.charAt(i) - word.charAt(i + 1)) > 2) {
+                count += calculateSubstrings(sb.toString(), k);
+                sb.setLength(0);
+            }
+        }
+        count += calculateSubstrings(sb.toString(), k);
+        return count;
+    }
+
+    private int calculateSubstrings(String s, int k) {
+        int count = 0;
+        int n = s.length();
+        for (int i = 1; i <= 26; i++) {
+            int len = k * i;
+            int[] freq = new int[26];
+            if (len > n) {
+                break;
+            }
+            for (int j = 0; j < len; j++) {
+                freq[s.charAt(j) - 'a']++;
+            }
+            if (check(freq, i, k)) {
+                count++;
+            }
+            for (int j = len; j < n; j++) {
+                freq[s.charAt(j - len) - 'a']--;
+                freq[s.charAt(j) - 'a']++;
+                if (check(freq, i, k)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    private boolean check(int[] freq, int i, int k) {
+        for (int value : freq) {
+            if (value == 0) {
+                continue;
+            }
+            if (value != k) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From ee241fbceafe5625316b337b7b5ec6dc7e72f5bb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 8 Dec 2023 10:18:30 -0800
Subject: [PATCH 1871/2175] Update Maximum Average Subtree.java

---
 Medium/Maximum Average Subtree.java | 44 ++++++++++++++++-------------
 1 file changed, 24 insertions(+), 20 deletions(-)

diff --git a/Medium/Maximum Average Subtree.java b/Medium/Maximum Average Subtree.java
index 97c54cf6..873f4f01 100644
--- a/Medium/Maximum Average Subtree.java	
+++ b/Medium/Maximum Average Subtree.java	
@@ -4,28 +4,32 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  double maxAvg;
-  public double maximumAverageSubtree(TreeNode root) {
-    maxAvg = 0.0;
-    helper(root);
-    return maxAvg;
-  }
-  
-  private int[] helper(TreeNode root) {
-    int[] data = new int[2];
-    if (root == null) {
-      return data;
+    public double maximumAverageSubtree(TreeNode root) {
+        double[] result = {0.0};
+        traverse(root, result);
+        return result[0];
+    }
+
+    private double[] traverse(TreeNode root, double[] result) {
+        if (root == null) {
+            return new double[]{0.0, 0.0};
+        }
+        double[] leftValues = traverse(root.left, result);
+        double[] rightValues = traverse(root.right, result);
+        double sum = root.val + leftValues[0] + rightValues[0];
+        double count = 1 + leftValues[1] + rightValues[1];
+        double avg = sum / count;
+        result[0] = Math.max(result[0], avg);
+        return new double[]{sum, count};
     }
-    int[] dataLeft = helper(root.left);
-    int[] dataRight = helper(root.right);
-    data[0] += root.val + dataLeft[0] + dataRight[0];
-    data[1] += 1 + dataLeft[1] + dataRight[1];
-    double avg = ((double) data[0]) / data[1];
-    maxAvg = Math.max(maxAvg, avg);
-    return data;
-  }
 }

From 36bbae100bd2b067bb375ccd1aab62de83b2c681 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Dec 2023 11:11:31 -0800
Subject: [PATCH 1872/2175] Create Find Common Elements Between Two Arrays.java

---
 ...nd Common Elements Between Two Arrays.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Easy/Find Common Elements Between Two Arrays.java

diff --git a/Easy/Find Common Elements Between Two Arrays.java b/Easy/Find Common Elements Between Two Arrays.java
new file mode 100644
index 00000000..4a6041ba
--- /dev/null
+++ b/Easy/Find Common Elements Between Two Arrays.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int[] findIntersectionValues(int[] nums1, int[] nums2) {
+        Map<Integer, Integer> map1 = buildFrequencyMap(nums1);
+        Map<Integer, Integer> map2 = buildFrequencyMap(nums2);
+        int[] result = new int[2];
+        for (Integer key : map1.keySet()) {
+            if (map2.containsKey(key)) {
+                result[0] += map1.get(key);
+            }
+        }
+        for (Integer key : map2.keySet()) {
+            if (map1.containsKey(key)) {
+                result[1] += map2.get(key);
+            }
+        }
+        return result;
+    }
+    
+    private static Map<Integer, Integer> buildFrequencyMap(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        return map;
+    }
+}

From 4a2ba34f2c830c227a65736e87e6b4a5b76e58a6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Dec 2023 11:15:13 -0800
Subject: [PATCH 1873/2175] Create Count Tested Devices After Test
 Operations.java

---
 .../Count Tested Devices After Test Operations.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Count Tested Devices After Test Operations.java

diff --git a/Easy/Count Tested Devices After Test Operations.java b/Easy/Count Tested Devices After Test Operations.java
new file mode 100644
index 00000000..1f6cdb0f
--- /dev/null
+++ b/Easy/Count Tested Devices After Test Operations.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int countTestedDevices(int[] batteryPercentages) {
+        int count = 0;
+        int diff = 0;
+        for (int batteryPercentage : batteryPercentages) {
+            if (Math.max(0, batteryPercentage - diff) > 0) {
+                count++;
+                diff++;
+            }
+        }
+        return count;
+    }
+}

From 9187cd95bed0cb1601d31b9a862e70b4f77ab5be Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Dec 2023 12:26:58 -0800
Subject: [PATCH 1874/2175] Create Remove Adjacent Almost-Equal Characters.java

---
 .../Remove Adjacent Almost-Equal Characters.java   | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Remove Adjacent Almost-Equal Characters.java

diff --git a/Medium/Remove Adjacent Almost-Equal Characters.java b/Medium/Remove Adjacent Almost-Equal Characters.java
new file mode 100644
index 00000000..46bdf2ab
--- /dev/null
+++ b/Medium/Remove Adjacent Almost-Equal Characters.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int removeAlmostEqualCharacters(String word) {
+        int count = 0;
+        for (int i = 0; i < word.length() - 1; i++) {
+            char curr = word.charAt(i);
+            char next = word.charAt(i + 1);
+            if (Math.abs(curr - next) <= 1) {
+                count++;
+                i++;
+            }
+        }
+        return count;
+    }
+}

From 1355423f65b4d3b6e4aa5ad40ecb660d4b0ecb93 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 13 Dec 2023 17:26:24 -0800
Subject: [PATCH 1875/2175] Create Difference Between Ones and Zeros in Row and
 Column.java

---
 ...ween Ones and Zeros in Row and Column.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Difference Between Ones and Zeros in Row and Column.java

diff --git a/Medium/Difference Between Ones and Zeros in Row and Column.java b/Medium/Difference Between Ones and Zeros in Row and Column.java
new file mode 100644
index 00000000..641b0b38
--- /dev/null
+++ b/Medium/Difference Between Ones and Zeros in Row and Column.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int[][] onesMinusZeros(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int[][] rowCount = new int[rows][2];
+        int[][] colCount = new int[cols][2];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                rowCount[i][0] += grid[i][j] == 1 ? 1 : 0;
+                rowCount[i][1] += grid[i][j] != 1 ? 1 : 0;
+                colCount[j][0] += grid[i][j] == 1 ? 1 : 0;
+                colCount[j][1] += grid[i][j] != 1 ? 1 : 0;
+            }
+        }
+        int[][] result = new int[rows][cols];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                result[i][j] = rowCount[i][0] + colCount[j][0] - rowCount[i][1] - colCount[j][1];
+            }
+        }
+        return result;
+    }
+}

From 02ccf71e0e466866b7e4d088332de2c7f4ecab03 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Dec 2023 07:39:12 -0800
Subject: [PATCH 1876/2175] Create Double Modular Exponentiation.java

---
 Medium/Double Modular Exponentiation.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Double Modular Exponentiation.java

diff --git a/Medium/Double Modular Exponentiation.java b/Medium/Double Modular Exponentiation.java
new file mode 100644
index 00000000..6dada495
--- /dev/null
+++ b/Medium/Double Modular Exponentiation.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public List<Integer> getGoodIndices(int[][] variables, int target) {
+        List<Integer> result = new ArrayList<>();
+        for (int i = 0; i < variables.length; i++) {
+            int a = variables[i][0];
+            int b = variables[i][1];
+            int c = variables[i][2];
+            int m = variables[i][3];
+            int base = 1;
+            for (int j = 0; j < b; j++) {
+                base = (base * a) % 10;
+            }
+            int value = 1;
+            for (int j = 0; j < c; j++) {
+                value = (value * base) % m;
+            }
+            if (value == target) {
+                result.add(i);
+            }
+        }
+        return result;
+    }
+}

From 847953331f0961ef8e7ba965f170bf78443f66c8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Dec 2023 17:53:24 -0800
Subject: [PATCH 1877/2175] Update Destination City.java

---
 Easy/Destination City.java | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Easy/Destination City.java b/Easy/Destination City.java
index c9f08cbc..f6e330ab 100644
--- a/Easy/Destination City.java	
+++ b/Easy/Destination City.java	
@@ -1,17 +1,12 @@
 class Solution {
-  public String destCity(List<List<String>> paths) {
-    Set<String> outgoingPathCities = new HashSet<>();
-    Set<String> cities = new HashSet<>();
-    for (List<String> path : paths) {
-      outgoingPathCities.add(path.get(0));
-      cities.add(path.get(0));
-      cities.add(path.get(1));
+    public String destCity(List<List<String>> paths) {
+        Set<String> cities = new HashSet<>();
+        Set<String> outgoingCities = new HashSet<>();
+        for (List<String> path : paths) {
+            cities.addAll(path);
+            outgoingCities.add(path.get(0));
+        }
+        cities.removeAll(outgoingCities);
+        return cities.iterator().next();
     }
-    for (String city : cities) {
-      if (!outgoingPathCities.contains(city)) {
-        return city;
-      }
-    }
-    return "";
-  }
 }

From a144dfd7beed7b924afcbaa04dd00742c93ad710 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Dec 2023 08:21:20 -0800
Subject: [PATCH 1878/2175] Create Design a Food Rating System.java

---
 Medium/Design a Food Rating System.java | 53 +++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 Medium/Design a Food Rating System.java

diff --git a/Medium/Design a Food Rating System.java b/Medium/Design a Food Rating System.java
new file mode 100644
index 00000000..71c55477
--- /dev/null
+++ b/Medium/Design a Food Rating System.java	
@@ -0,0 +1,53 @@
+class FoodRatings {
+
+    private final Map<String, Integer> foodToRating;
+
+    private final Map<String, String> foodToCuisine;
+
+    private final Map<String, PriorityQueue<Food>> cuisineToFood;
+
+    public FoodRatings(String[] foods, String[] cuisines, int[] ratings) {
+        this.foodToRating = new HashMap<>();
+        this.foodToCuisine = new HashMap<>();
+        this.cuisineToFood = new HashMap<>();
+        for (int i = 0; i < foods.length; i++) {
+            String food = foods[i];
+            String cuisine = cuisines[i];
+            int rating = ratings[i];
+            foodToRating.put(food, rating);
+            foodToCuisine.put(food, cuisine);
+            cuisineToFood.computeIfAbsent(cuisine, k -> new PriorityQueue<>()).add(new Food(food, rating));
+        }
+    }
+
+    public void changeRating(String food, int newRating) {
+        this.foodToRating.put(food, newRating);
+        String cuisine = foodToCuisine.get(food);
+        cuisineToFood.get(cuisine).add(new Food(food, newRating));
+    }
+
+    public String highestRated(String cuisine) {
+        Food highestRatedFood = cuisineToFood.get(cuisine).peek();
+        while (foodToRating.get(highestRatedFood.name) != highestRatedFood.rating) {
+            cuisineToFood.get(cuisine).poll();
+            highestRatedFood = cuisineToFood.get(cuisine).peek();
+        }
+        return highestRatedFood.name;
+    }
+
+    private record Food(String name, int rating) implements Comparable<Food> {
+        @Override
+        public int compareTo(Food o) {
+            int c = o.rating - rating;
+            return c == 0 ? name.compareTo(o.name) : c;
+        }
+    }
+}
+
+
+/**
+ * Your FoodRatings object will be instantiated and called as such:
+ * FoodRatings obj = new FoodRatings(foods, cuisines, ratings);
+ * obj.changeRating(food,newRating);
+ * String param_2 = obj.highestRated(cuisine);
+ */

From 6a5b18f6201ffcd24d488c9fb6018381fc93d771 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Dec 2023 11:44:36 -0800
Subject: [PATCH 1879/2175] Create Find Missing and Repeated Values.java

---
 Easy/Find Missing and Repeated Values.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Find Missing and Repeated Values.java

diff --git a/Easy/Find Missing and Repeated Values.java b/Easy/Find Missing and Repeated Values.java
new file mode 100644
index 00000000..52cf256e
--- /dev/null
+++ b/Easy/Find Missing and Repeated Values.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int[] findMissingAndRepeatedValues(int[][] grid) {
+        int n = grid.length;
+        int[] frequency = new int[n * n + 1];
+        for (int[] row : grid) {
+            for (int num : row) {
+                frequency[num]++;
+            }
+        }
+        int[] result = new int[2];
+        for (int i = 1; i <= n * n; i++) {
+            if (frequency[i] == 0) {
+                result[1] = i;
+            }
+            if (frequency[i] == 2) {
+                result[0] = i;
+            }
+        }
+        return result;
+    }
+}

From 9f0730eb747f6e3d8cc383a009529f3b8f1a2a97 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 18 Dec 2023 09:32:47 -0800
Subject: [PATCH 1880/2175] Create Divide Array Into Arrays With Max
 Difference.java

---
 ...ide Array Into Arrays With Max Difference.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Divide Array Into Arrays With Max Difference.java

diff --git a/Medium/Divide Array Into Arrays With Max Difference.java b/Medium/Divide Array Into Arrays With Max Difference.java
new file mode 100644
index 00000000..77959768
--- /dev/null
+++ b/Medium/Divide Array Into Arrays With Max Difference.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int[][] divideArray(int[] nums, int k) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int[][] result = new int[n / 3][3];
+        int idx = 0;
+        for (int i = 2; i < nums.length; i += 3) {
+            if (nums[i] - nums[i - 2] > k) {
+                return new int[][]{};
+            }
+            result[idx++] = new int[]{nums[i - 2], nums[i - 1], nums[i]};
+        }
+        return result;
+    }
+}

From 3b43dac141a1cc49ef215ebedbb158c93784d8eb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 19 Dec 2023 07:36:03 -0800
Subject: [PATCH 1881/2175] Update Image Smoother.java

---
 Easy/Image Smoother.java | 64 +++++++++++++---------------------------
 1 file changed, 21 insertions(+), 43 deletions(-)

diff --git a/Easy/Image Smoother.java b/Easy/Image Smoother.java
index 9f0d68f0..ede06daf 100644
--- a/Easy/Image Smoother.java	
+++ b/Easy/Image Smoother.java	
@@ -1,49 +1,27 @@
 class Solution {
-    public int[][] imageSmoother(int[][] M) {
-        
-        int[][] res = new int[M.length][M[0].length];
-        for (int i=0;i<M.length;i++) {
-            for (int j=0;j<M[0].length;j++) {
+
+    private static final int[][] DIRS = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}, {1, -1}, {-1, 1}, {1, 1}, {-1, -1}};
+
+    public int[][] imageSmoother(int[][] img) {
+        int rows = img.length;
+        int cols = img[0].length;
+        int[][] result = new int[rows][cols];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                double sum = img[i][j];
                 int count = 1;
-                int sum = M[i][j];
-                
-                if(j-1 >= 0) {
-                    count++;
-                    sum += M[i][j-1];
-                }
-                if(j+1 < M[0].length) {
-                    count++;
-                    sum += M[i][j+1];
-                }
-                if(i-1 >= 0) {
-                    count++;
-                    sum += M[i-1][j];
-                }
-                if(i+1 < M.length) {
-                    count++;
-                    sum += M[i+1][j];
-                }
-                if(i+1 < M.length && j+1 < M[0].length) {
-                    count++;
-                    sum += M[i+1][j+1];
-                }
-                if(i+1 < M.length && j-1 >= 0) {
-                    count++;
-                    sum += M[i+1][j-1];
-                }
-                if(i-1 >= 0 && j-1 >= 0) {
-                    count++;
-                    sum += M[i-1][j-1];
-                }
-                if(i-1 >= 0 && j+1 < M[0].length) {
-                    count++;
-                    sum += M[i-1][j+1];
-                }
-                
-                res[i][j] = (int)Math.floor(sum/count);
+                for (int[] dir : DIRS) {
+                    int row = i + dir[0];
+                    int col = j + dir[1];
+                    if (row >= 0 && row < rows && col >= 0 && col < cols) {
+                        sum += img[row][col];
+                        count++;
+                    }
+                }
+                double smoothImage = sum / count;
+                result[i][j] = (int) smoothImage;
             }
         }
-        
-        return res;
+        return result;
     }
 }

From 8f41cdff81fd1d5b35ebe3867a8ffb3e605e0814 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 21 Dec 2023 07:31:40 -0800
Subject: [PATCH 1882/2175] Create Widest Vertical Area Between Two Points
 Containing No Points.java

---
 ... Area Between Two Points Containing No Points.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Widest Vertical Area Between Two Points Containing No Points.java

diff --git a/Medium/Widest Vertical Area Between Two Points Containing No Points.java b/Medium/Widest Vertical Area Between Two Points Containing No Points.java
new file mode 100644
index 00000000..d2e07d21
--- /dev/null
+++ b/Medium/Widest Vertical Area Between Two Points Containing No Points.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int maxWidthOfVerticalArea(int[][] points) {
+        Arrays.sort(points, (a, b) -> a[0] - b[0]);
+        int maxWidth = 0;
+        for (int i = 1; i < points.length; i++) {
+            int width = points[i][0] - points[i - 1][0];
+            maxWidth = Math.max(maxWidth, width);
+        }
+        return maxWidth;
+    }
+}

From 6e84385d2034cfc65946e25bb5d7a5b2151b7644 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Dec 2023 08:10:18 -0800
Subject: [PATCH 1883/2175] Create Maximum Score After Splitting a String.java

---
 .../Maximum Score After Splitting a String.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Maximum Score After Splitting a String.java

diff --git a/Easy/Maximum Score After Splitting a String.java b/Easy/Maximum Score After Splitting a String.java
new file mode 100644
index 00000000..60649ebf
--- /dev/null
+++ b/Easy/Maximum Score After Splitting a String.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxScore(String s) {
+        int n = s.length();
+        int ones = 0;
+        for (int i = 0; i < n; i++) {
+            ones += s.charAt(i) == '1' ? 1 : 0;
+        }
+        int score = 0;
+        int zeros = 0;
+        for (int i = 0; i < n - 1; i++) {
+            ones -= s.charAt(i) == '1' ? 1 : 0;
+            zeros += s.charAt(i) == '0' ? 1 : 0;
+            score = Math.max(score, zeros + ones);
+        }
+        return score;
+    }
+}

From e8a9a698819cd069512fd6523f6cffe85142344f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Dec 2023 12:26:39 -0800
Subject: [PATCH 1884/2175] Update Longest Substring with At Most Two Distinct
 Characters.java

---
 ... with At Most Two Distinct Characters.java | 36 +++++++++----------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/Medium/Longest Substring with At Most Two Distinct Characters.java b/Medium/Longest Substring with At Most Two Distinct Characters.java
index 2af3a613..04f60a83 100644
--- a/Medium/Longest Substring with At Most Two Distinct Characters.java	
+++ b/Medium/Longest Substring with At Most Two Distinct Characters.java	
@@ -1,22 +1,22 @@
 class Solution {
-  public int lengthOfLongestSubstringTwoDistinct(String s) {
-    Map<Character, Integer> map = new HashMap<>();
-    int startIdx = 0;
-    int endIdx = 0;
-    int n = s.length();
-    int maxLength = 0;
-    while (endIdx < n) {
-      map.put(s.charAt(endIdx), map.getOrDefault(s.charAt(endIdx), 0) + 1);
-      while (startIdx < endIdx && map.size() > 2) {
-        map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0) - 1);
-        if (map.get(s.charAt(startIdx)) <= 0) {
-          map.remove(s.charAt(startIdx));
+    public int lengthOfLongestSubstringTwoDistinct(String s) {
+        int max = 0;
+        int start = 0;
+        int end = 0;
+        int n = s.length();
+        Map<Character, Integer> map = new HashMap<>();
+        while (end < n) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            end++;
+            while (start < end && map.size() > 2) {
+                map.put(s.charAt(start), map.getOrDefault(s.charAt(start), 0) - 1);
+                if (map.get(s.charAt(start)) == 0) {
+                    map.remove(s.charAt(start));
+                }
+                start++;
+            }
+            max = Math.max(max, end - start);
         }
-        startIdx++;
-      }
-      endIdx++;
-      maxLength = Math.max(endIdx - startIdx, maxLength);
+        return max;
     }
-    return maxLength;
-  }
 }

From feecd250c72dac3916b910fe417c20a596d113b3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Dec 2023 08:40:33 -0800
Subject: [PATCH 1885/2175] Update Path Crossing.java

---
 Easy/Path Crossing.java | 44 ++++++++++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 18 deletions(-)

diff --git a/Easy/Path Crossing.java b/Easy/Path Crossing.java
index 32b241c3..e3f7d9a9 100644
--- a/Easy/Path Crossing.java	
+++ b/Easy/Path Crossing.java	
@@ -1,21 +1,29 @@
 class Solution {
-  int[][] dirs = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
-  public boolean isPathCrossing(String path) {
-    Set<String> set = new HashSet<>();
-    int currX = 0;
-    int currY = 0;
-    String dirSymbol = "NSEW";
-    set.add(currX + "|" + currY);
-    for (char c : path.toCharArray()) {
-      int dirIdx = dirSymbol.indexOf(c);
-      currX += dirs[dirIdx][0];
-      currY += dirs[dirIdx][1];
-      String hash = currX + "|" + currY;
-      if (set.contains(hash)) {
-        return true;
-      }
-      set.add(hash);
+    public boolean isPathCrossing(String path) {
+        Set<String> visited = new HashSet<>();
+        visited.add("0|0");
+        int x = 0;
+        int y = 0;
+        for (Character step : path.toCharArray()) {
+            switch (step) {
+                case 'N':
+                    x++;
+                    break;
+                case 'S':
+                    x--;
+                    break;
+                case 'E':
+                    y--;
+                    break;
+                case 'W':
+                    y++;
+                    break;
+            }
+            String key = x + "|" + y;
+            if (!visited.add(key)) {
+                return true;
+            }
+        }
+        return false;
     }
-    return false;
-  }
 }

From 85f5352083dcee5950f3ad52194876b7a7464c23 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 24 Dec 2023 07:20:23 -0800
Subject: [PATCH 1886/2175] Update Minimum Changes To Make Alternating Binary
 String.java

---
 ...ges To Make Alternating Binary String.java | 21 ++++++++++++-------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/Easy/Minimum Changes To Make Alternating Binary String.java b/Easy/Minimum Changes To Make Alternating Binary String.java
index 539d9a42..95f9aaae 100644
--- a/Easy/Minimum Changes To Make Alternating Binary String.java	
+++ b/Easy/Minimum Changes To Make Alternating Binary String.java	
@@ -1,11 +1,16 @@
 class Solution {
-  public int minOperations(String s) {
-    int numOfChanges = 0;
-    for (int i = 0; i < s.length(); i++) {
-      if (s.charAt(i) - '0' != i % 2) {
-        numOfChanges++;
-      }
+    public int minOperations(String s) {
+        int startZero = 0;
+        int startOne = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (i % 2 == 0) {
+                startOne += s.charAt(i) == '0' ? 1 : 0;
+                startZero += s.charAt(i) == '1' ? 1 : 0;
+            } else {
+                startOne += s.charAt(i) == '1' ? 1 : 0;
+                startZero += s.charAt(i) == '0' ? 1 : 0;
+            }
+        }
+        return Math.min(startZero, startOne);
     }
-    return Math.min(numOfChanges, s.length() - numOfChanges);
-  }
 }

From 3552e0f598b987be4f311c1e536cbc072108a122 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Dec 2023 07:43:32 -0800
Subject: [PATCH 1887/2175] Update Number of Dice Rolls With Target Sum.java

---
 .../Number of Dice Rolls With Target Sum.java | 50 ++++++++++---------
 1 file changed, 27 insertions(+), 23 deletions(-)

diff --git a/Medium/Number of Dice Rolls With Target Sum.java b/Medium/Number of Dice Rolls With Target Sum.java
index 6e600168..e192518a 100644
--- a/Medium/Number of Dice Rolls With Target Sum.java	
+++ b/Medium/Number of Dice Rolls With Target Sum.java	
@@ -1,27 +1,31 @@
 class Solution {
-  Map<String, Integer> map = new HashMap<>();
-  final int MODULO = 1000000007;
-  public int numRollsToTarget(int d, int f, int target) {
-    if (d == 0 && target == 0) {
-      return 1;
+
+    private static final int MOD = 1000_000_007;
+
+    public int numRollsToTarget(int n, int k, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        return helper(n, k, target, map);
     }
-    if (d == 0 || target == 0) {
-      return 0;
+
+    private int helper(int n, int k, int target, Map<Integer, Integer> map) {
+        if (n == 0 && target == 0) {
+            return 1;
+        }
+        if (n == 0 || target == 0) {
+            return 0;
+        }
+        int key = n * 1000 + target;
+        if (map.containsKey(key)) {
+            return map.get(key);
+        }
+        int result = 0;
+        for (int i = 1; i <= k; i++) {
+            if (target < i) {
+                break;
+            }
+            result = (result + helper(n - 1, k, target - i, map)) % MOD;
+        }
+        map.put(key, result);
+        return result;
     }
-    String key = d + "|" + target;
-    if (map.containsKey(key)) {
-      return map.get(key);
-    }
-    int res = 0;
-    for (int i = 1; i <= f; i++) {
-      if (target >= i) {
-        res = (res + numRollsToTarget(d - 1, f, target - i)) % MODULO;
-      }
-      else {
-        break;
-      }
-    }
-    map.put(key, res);
-    return map.get(key);
-  }
 }

From 7891aaa65276452f74a335c3095da57d4362f84c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Dec 2023 07:47:30 -0800
Subject: [PATCH 1888/2175] Create Minimum Number Game.java

---
 Easy/Minimum Number Game.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Minimum Number Game.java

diff --git a/Easy/Minimum Number Game.java b/Easy/Minimum Number Game.java
new file mode 100644
index 00000000..a3377cb7
--- /dev/null
+++ b/Easy/Minimum Number Game.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int[] numberGame(int[] nums) {
+        int[] result = new int[nums.length];
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length; i += 2) {
+            result[i] = nums[i + 1];
+            result[i + 1] = nums[i];
+        }
+        return result;
+    }
+}

From c4505bfb84748231912291819dd8eead17dfb16b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Dec 2023 17:28:19 -0800
Subject: [PATCH 1889/2175] Update Minimum Time to Make Rope Colorful.java

---
 .../Minimum Time to Make Rope Colorful.java   | 32 +++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/Medium/Minimum Time to Make Rope Colorful.java b/Medium/Minimum Time to Make Rope Colorful.java
index 97cc34e1..3fdc7e26 100644
--- a/Medium/Minimum Time to Make Rope Colorful.java	
+++ b/Medium/Minimum Time to Make Rope Colorful.java	
@@ -1,19 +1,19 @@
 class Solution {
-  public int minCost(String colors, int[] neededTime) {
-    int totalTime = 0;
-    int left = 0;
-    int right = 0;
-    while (right < colors.length()) {
-      int currTotal = 0;
-      int currMax = 0;
-      while (left < neededTime.length && colors.charAt(right) == colors.charAt(left)) {
-        currTotal += neededTime[left];
-        currMax = Math.max(currMax, neededTime[left]);
-        left++;
-      }
-      totalTime += currTotal - currMax;
-      right = left;
+    public int minCost(String colors, int[] neededTime) {
+        Stack<Integer> stack = new Stack<>();
+        int cost = 0;
+        for (int i = 0; i < colors.length(); i++) {
+            if (stack.isEmpty() || colors.charAt(i) != colors.charAt(stack.peek())) {
+                stack.push(i);
+                continue;
+            }
+            if (neededTime[i] > neededTime[stack.peek()]) {
+                cost += neededTime[stack.pop()];
+                stack.push(i);
+            } else {
+                cost += neededTime[i]; 
+            }
+        }
+        return cost;
     }
-    return totalTime;
-  }
 }

From ddcb14efbe1a54349dca61da5587fdcf283d2186 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Dec 2023 10:18:05 -0800
Subject: [PATCH 1890/2175] Update String Compression II.java

---
 Hard/String Compression II.java | 115 +++++++++++++++-----------------
 1 file changed, 52 insertions(+), 63 deletions(-)

diff --git a/Hard/String Compression II.java b/Hard/String Compression II.java
index d2f3d371..ac420adf 100644
--- a/Hard/String Compression II.java	
+++ b/Hard/String Compression II.java	
@@ -1,69 +1,58 @@
 class Solution {
-  
-  /**
-  * First dimension : Current index
-  * Second dimension : Amount of available deletions
-  * Third dimension : Index of previous character
-  * Fourth dimension : Consecutive count of previous character
-  */
-  private static int[][][][] dp = new int[100][101][100][26];
-  
-  public int getLengthOfOptimalCompression(String s, int k) {
-    int n = s.length();
-    for(int i = 0; i < n; i++) {
-      for(int j = 0; j <= k; j++) {
-        for(int z = 0; z < n; z++) {
-          for(int l = 0; l < 26; l++) {
-            dp[i][j][z][l]=-1;
-          }
+
+    private static int[][][][] dp = new int[100][101][100][26];
+
+    public int getLengthOfOptimalCompression(String s, int k) {
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j <= k; j++) {
+                for (int x = 0; x < n; x++) {
+                    for (int y = 0; y < 26; y++) {
+                        dp[i][j][x][y] = -1;
+                    }
+                }
+            }
         }
-      }
+        return solver(s.toCharArray(), 0, k, 0, s.charAt(0));
     }
-    return best(s.toCharArray(), /* idx= */ 0, k, /* count= */ 0, /* prevChar= */ s.charAt(0));
-  }
-  
-  private int best(char[] letters, int idx, int k, int count, char prevChar) {
-    if (idx == letters.length) {
-      return countNumberOfLetters(count);
-    }
-    if (dp[idx][k][count][prevChar - 'a'] != -1) {
-      return dp[idx][k][count][prevChar - 'a'];
-    }
-    if (k == 0) {
-      int result = 0;
-      if (letters[idx] == prevChar) {
-        result = best(letters, idx + 1, k, count + 1, prevChar);
-      } else {
-        result = countNumberOfLetters(count) + best(letters, idx + 1, k, 1, letters[idx]);
-      }
-      dp[idx][k][count][prevChar - 'a'] = result;
-      return result;
-    }
-    int result = 0;
-    if (letters[idx] == prevChar) {
-      result = Math.min(
-        best(letters, idx + 1, k, count + 1, prevChar), // Delete and recurse forward
-        best(letters, idx + 1, k - 1, count, prevChar)); // Don't delete and recurse forward
-    } else {
-      result = Math.min(
-        countNumberOfLetters(count) + best(letters, idx + 1, k, /* count= */ 1, /* prevChar= */ letters[idx]), // Don't delete current char and recurse forward with new count
-        best(letters, idx + 1, k - 1, count, prevChar)); // Delete current character and recurse forward
-    }
-    dp[idx][k][count][prevChar - 'a'] = result;
-    return result;
-  }
-  
-  private static int countNumberOfLetters(int count) {
-    if (count == 0) {
-      return count;
+
+    private int solver(char[] letters, int idx, int k, int currFrequency, char prevChar) {
+        if (idx == letters.length) {
+            return getLetterCount(currFrequency);
+        }
+        if (dp[idx][k][currFrequency][prevChar - 'a'] != -1) {
+            return dp[idx][k][currFrequency][prevChar - 'a'];
+        }
+        int result = 0;
+        if (letters[idx] == prevChar) {
+            result = k == 0 ? 
+                solver(letters, idx + 1, k, currFrequency + 1, prevChar) : 
+                Math.min(
+                    solver(letters, idx + 1, k , currFrequency + 1, prevChar), // don't delete
+                    solver(letters, idx + 1, k - 1 , currFrequency, prevChar) // delete
+                );
+        } else {
+            result = k == 0 ?
+                getLetterCount(currFrequency) + solver(letters, idx + 1, k, 1, letters[idx]) :
+                Math.min(
+                    getLetterCount(currFrequency) + solver(letters, idx + 1, k, 1, letters[idx]), // don't delete
+                    solver(letters, idx + 1, k - 1, currFrequency, prevChar) // delete
+                );
+        }
+        return dp[idx][k][currFrequency][prevChar - 'a'] = result;
     }
-    int numberOfDigits = 1;
-    if (count > 9) {
-      numberOfDigits = 2;
-    } 
-    if (count > 99) {
-      numberOfDigits = 3;
+
+    private static int getLetterCount(int frequency) {
+        if (frequency == 0) {
+            return 0;
+        }
+        int digits = 1;
+        if (frequency > 9) {
+            digits = 2;
+        }
+        if (frequency > 99) {
+            digits = 3;
+        }
+        return frequency == 1 ? 1 : (digits + 1);
     }
-    return count == 1 ? 1 : (numberOfDigits + 1);
-  }
 }

From bd407202de2446c8dfa576516865b4b2034e140d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Dec 2023 10:44:34 -0800
Subject: [PATCH 1891/2175] Update Minimum Difficulty of a Job Schedule.java

---
 .../Minimum Difficulty of a Job Schedule.java | 52 +++++++++----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/Hard/Minimum Difficulty of a Job Schedule.java b/Hard/Minimum Difficulty of a Job Schedule.java
index 58722245..ebc94cc7 100644
--- a/Hard/Minimum Difficulty of a Job Schedule.java	
+++ b/Hard/Minimum Difficulty of a Job Schedule.java	
@@ -1,30 +1,30 @@
 class Solution {
-  public int minDifficulty(int[] jobDifficulty, int d) {
-    int n = jobDifficulty.length;
-    if (n < d) {
-      return -1;
+    
+    private static final int INVALID_VALUE = 300_001;
+
+    public int minDifficulty(int[] jobDifficulty, int d) {
+        if (jobDifficulty.length < d) {
+            return -1;
+        }
+        Integer[][][] dp = new Integer[jobDifficulty.length][d + 1][1001];
+        return dfs(jobDifficulty, 0, d, 0, dp);
     }
-    Integer[][] dp = new Integer[n][d + 1];
-    return minDifficulty(/* index= */0, d, jobDifficulty, dp);
-  }
-  
-  private int minDifficulty(int index, int dLeft, int[] jobDifficulty, Integer[][] dp)  {
-    if (dp[index][dLeft] != null) {
-      return dp[index][dLeft];
+
+    private int dfs(int[] jobDifficulty, int idx, int d, int currMax, Integer[][][] dp) {
+        if (idx == jobDifficulty.length) {
+            return d == 0 ? 0 : INVALID_VALUE;
+        }
+        if (d == 0) {
+            return INVALID_VALUE;
+        }
+        if (dp[idx][d][currMax] != null) {
+            return dp[idx][d][currMax];
+        }
+        currMax = Math.max(currMax, jobDifficulty[idx]);
+        int result = Math.min(dfs(
+                jobDifficulty, idx + 1, d, currMax, dp), // continue same sequence
+                currMax + dfs(jobDifficulty, idx + 1, d - 1, 0, dp) // break sequence
+        );
+        return dp[idx][d][currMax] = result;
     }
-    if (dLeft == 1) {
-      int result = 0;
-      for (int j = index; j < jobDifficulty.length; j++) {
-        result = Math.max(result, jobDifficulty[j]);
-      }
-      return result;
-    }
-    int result = Integer.MAX_VALUE;
-    int dailyMaxJobDiff = 0;
-    for (int j = index; j < jobDifficulty.length - dLeft + 1; j++) {
-      dailyMaxJobDiff = Math.max(dailyMaxJobDiff, jobDifficulty[j]);
-      result = Math.min(result, dailyMaxJobDiff + minDifficulty(j + 1, dLeft - 1, jobDifficulty, dp));
-    }
-    return dp[index][dLeft] = result;
-  } 
 }

From 815d3e73700a4af1bec530035ac8264ebd4bb041 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 29 Dec 2023 10:58:42 -0800
Subject: [PATCH 1892/2175] Create Valid Palindrome III.java

---
 Hard/Valid Palindrome III.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Hard/Valid Palindrome III.java

diff --git a/Hard/Valid Palindrome III.java b/Hard/Valid Palindrome III.java
new file mode 100644
index 00000000..dc97a304
--- /dev/null
+++ b/Hard/Valid Palindrome III.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public boolean isValidPalindrome(String s, int k) {
+        int n = s.length();
+        Integer[][] dp = new Integer[n][n];
+        return isValidPalindrome(s, 0, n - 1, dp) <= k;
+    }
+
+    private int isValidPalindrome(String s, int left, int right, Integer[][] dp) {
+        if (left == right) {
+            return 0;
+        }
+        if (left == right - 1) {
+            return s.charAt(left) != s.charAt(right) ? 1 : 0;
+        }
+        if (dp[left][right] != null) {
+            return dp[left][right];
+        }
+        if (s.charAt(left) == s.charAt(right)) {
+            return isValidPalindrome(s, left + 1, right - 1, dp); // move both pointers
+        }
+        return dp[left][right] = 1 + Math.min(
+            isValidPalindrome(s, left + 1, right, dp), // move only left pointer
+            isValidPalindrome(s, left, right - 1, dp) // move only right pointer
+        );
+    }
+}

From 5fff8fb179026d7a7bafb646479e42345f7330df Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Dec 2023 17:55:12 -0800
Subject: [PATCH 1893/2175] Update Largest Substring Between Two Equal
 Characters.java

---
 ... Substring Between Two Equal Characters.java | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/Easy/Largest Substring Between Two Equal Characters.java b/Easy/Largest Substring Between Two Equal Characters.java
index fa0d8495..24371003 100644
--- a/Easy/Largest Substring Between Two Equal Characters.java	
+++ b/Easy/Largest Substring Between Two Equal Characters.java	
@@ -1,12 +1,11 @@
 class Solution {
-  public int maxLengthBetweenEqualCharacters(String s) {
-    Map<Character, Integer> startIndex = new HashMap<>();
-    int largestSubstringLength = -1;
-    for (int i = 0; i < s.length(); i++) {
-      char c = s.charAt(i);
-      startIndex.putIfAbsent(c, i);
-      largestSubstringLength = Math.max(largestSubstringLength, i - startIndex.get(c) - 1);
+    public int maxLengthBetweenEqualCharacters(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int maxLength = -1;
+        for (int i = 0; i < s.length(); i++) {
+            map.putIfAbsent(s.charAt(i), i);
+            maxLength = Math.max(maxLength, i - map.get(s.charAt(i)) - 1);
+        }
+        return maxLength;
     }
-    return largestSubstringLength;
-  }
 }

From f408c474be863412fa785f556a718d8fb771ba2b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Dec 2023 15:49:41 -0800
Subject: [PATCH 1894/2175] Create Check if Bitwise OR Has Trailing Zeros.java

---
 Easy/Check if Bitwise OR Has Trailing Zeros.java | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Easy/Check if Bitwise OR Has Trailing Zeros.java

diff --git a/Easy/Check if Bitwise OR Has Trailing Zeros.java b/Easy/Check if Bitwise OR Has Trailing Zeros.java
new file mode 100644
index 00000000..b1aedc22
--- /dev/null
+++ b/Easy/Check if Bitwise OR Has Trailing Zeros.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public boolean hasTrailingZeros(int[] nums) {
+        return Arrays.stream(nums)
+                .filter(num -> Integer.numberOfTrailingZeros(num) > 0)
+                .count() >= 2;
+    }
+}

From d506f5543729c389424c5a2566977f0bb805fc27 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 1 Jan 2024 08:48:41 -0800
Subject: [PATCH 1895/2175] Update Assign Cookies.java

---
 Easy/Assign Cookies.java | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/Easy/Assign Cookies.java b/Easy/Assign Cookies.java
index 6ff366ad..32b09bf6 100644
--- a/Easy/Assign Cookies.java	
+++ b/Easy/Assign Cookies.java	
@@ -1,15 +1,13 @@
 class Solution {
-  public int findContentChildren(int[] g, int[] s) {
-    Arrays.sort(g);
-    Arrays.sort(s);
-    int gIdx = 0;
-    int sIdx = 0;
-    while (sIdx < s.length && gIdx < g.length) {
-      if (s[sIdx] >= g[gIdx]) {
-        gIdx++;
-      }
-      sIdx++;
+    public int findContentChildren(int[] greed, int[] cookieSize) {
+        Arrays.sort(greed);
+        Arrays.sort(cookieSize);
+        int idx = 0;
+        for (int i = 0; i < cookieSize.length && idx < greed.length; i++) {
+            if (cookieSize[i] >= greed[idx]) {
+                idx++;
+            }
+        }
+        return idx;
     }
-    return gIdx;
-  }
 }

From 62bf7ccabb4ea9bc3ea9f060f58e872d0b91664b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 2 Jan 2024 13:14:49 -0800
Subject: [PATCH 1896/2175] Update Campus Bikes II.java

---
 Medium/Campus Bikes II.java | 48 ++++++++++++++++++-------------------
 1 file changed, 23 insertions(+), 25 deletions(-)

diff --git a/Medium/Campus Bikes II.java b/Medium/Campus Bikes II.java
index 82de40c4..692725d0 100644
--- a/Medium/Campus Bikes II.java	
+++ b/Medium/Campus Bikes II.java	
@@ -1,30 +1,28 @@
 class Solution {
-  int minDist;
-  public int assignBikes(int[][] workers, int[][] bikes) {
-    minDist = Integer.MAX_VALUE;
-    dfs(new boolean[bikes.length], workers, 0, bikes, 0);
-    return minDist;
-  }
-  
-  private void dfs(boolean[] visited, int[][] workers, int currIdx, int[][] bikes, int distance) {
-    if (currIdx >= workers.length) {
-      minDist = Math.min(minDist, distance);
-      return;
+    public int assignBikes(int[][] workers, int[][] bikes) {
+        Integer[] dp = new Integer[1024];
+        return minDistance(workers, bikes, 0, 0, dp);
     }
-    if (distance > minDist) {
-      return;
+
+    private int minDistance(int[][] workers, int[][] bikes, int workerIdx, int mask, Integer[] dp) {
+        if (workerIdx >= workers.length) {
+            return 0;
+        }
+        if (dp[mask] != null) {
+            return dp[mask];
+        }
+        int distance = Integer.MAX_VALUE;
+        for (int i = 0; i < bikes.length; i++) {
+            // if bike is available
+            if ((mask & (1 << i)) == 0) {
+                // assign the bike & traverse for remaining bikes
+                distance = Math.min(distance, calculateManhattanDistance(workers[workerIdx], bikes[i]) + minDistance(workers, bikes, workerIdx + 1, mask | (1 << i), dp));
+            }
+        }
+        return dp[mask] = distance;
     }
-    for (int i = 0; i < bikes.length; i++) {
-      if (visited[i]) {
-        continue;
-      }
-      visited[i] = true;
-      dfs(visited, workers, currIdx + 1, bikes, distance + getManahattanDist(bikes[i], workers[currIdx]));
-      visited[i] = false;
+
+    private static int calculateManhattanDistance(int[] worker, int[] bike) {
+        return Math.abs(worker[0] - bike[0]) + Math.abs(worker[1] - bike[1]);
     }
-  }
-  
-  private int getManahattanDist(int[] p1, int[] p2) {
-    return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
-  }
 }

From ff19e288647f03ad4855db273e5598377087648e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 3 Jan 2024 07:45:58 -0800
Subject: [PATCH 1897/2175] Update Number of Laser Beams in a Bank.java

---
 Medium/Number of Laser Beams in a Bank.java | 26 +++++++++++----------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/Medium/Number of Laser Beams in a Bank.java b/Medium/Number of Laser Beams in a Bank.java
index 9a03ad92..ce39e8bd 100644
--- a/Medium/Number of Laser Beams in a Bank.java	
+++ b/Medium/Number of Laser Beams in a Bank.java	
@@ -1,15 +1,17 @@
 class Solution {
-  public int numberOfBeams(String[] bank) {
-    int prevLaserCount = 0;
-    int totalNumberOfBeams = 0;
-    for (String beam : bank) {
-      if (beam.indexOf('1') != -1) {
-        int currentBeamCount = (int) beam.chars().mapToObj(c -> (char) c).filter(c -> c == '1')
-            .count();
-        totalNumberOfBeams += prevLaserCount * currentBeamCount;
-        prevLaserCount = currentBeamCount;
-      }
+    public int numberOfBeams(String[] bank) {
+        int beamCount = 0;
+        int prevLaserCount = 0;
+        for (String row : bank) {
+            int count = 0;
+            for (char c : row.toCharArray()) {
+                count += c == '1' ? 1 : 0;
+            }
+            if (count > 0) {
+                beamCount += prevLaserCount * count;
+                prevLaserCount = count;
+            }
+        }
+        return beamCount;
     }
-    return totalNumberOfBeams;
-  }
 }

From 9cfddc49e9f473e101c449edc549ea8ab82f26be Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Jan 2024 08:17:53 -0800
Subject: [PATCH 1898/2175] Update Minimum Number of Operations to Make Array
 Empty.java

---
 ...mum Number of Operations to Make Array Empty.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Medium/Minimum Number of Operations to Make Array Empty.java b/Medium/Minimum Number of Operations to Make Array Empty.java
index e132e463..69754a8d 100644
--- a/Medium/Minimum Number of Operations to Make Array Empty.java	
+++ b/Medium/Minimum Number of Operations to Make Array Empty.java	
@@ -1,15 +1,15 @@
 class Solution {
     public int minOperations(int[] nums) {
-        Map<Integer, Long> map = Arrays.stream(nums)
-        .boxed()
-        .collect(
-            Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
         int operations = 0;
-        for (Long value : map.values()) {
+        for (Integer value : map.values()) {
             if (value == 1) {
                 return -1;
             }
-            operations += (int) (value / 3 + (value % 3 != 0 ? 1 : 0));
+            operations += value / 3 + (value % 3 == 0 ? 0 : 1);
         }
         return operations;
     }

From b4e3fc80af398a79b1ab054619676fc67e988a8c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 5 Jan 2024 07:26:21 -0800
Subject: [PATCH 1899/2175] Update Longest Increasing Subsequence.java

---
 Medium/Longest Increasing Subsequence.java | 29 +++++++++++-----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/Medium/Longest Increasing Subsequence.java b/Medium/Longest Increasing Subsequence.java
index a4607634..b56c14ef 100644
--- a/Medium/Longest Increasing Subsequence.java	
+++ b/Medium/Longest Increasing Subsequence.java	
@@ -1,19 +1,18 @@
 class Solution {
-  public int lengthOfLIS(int[] nums) {
-    List<Integer> subsequence = new ArrayList<>();
-    subsequence.add(nums[0]);
-    for (int i = 1; i < nums.length; i++) {
-      int currNum = nums[i];
-      if (currNum > subsequence.get(subsequence.size() - 1)) {
-        subsequence.add(currNum);
-      } else {
-        int idx = 0;
-        while (currNum > subsequence.get(idx)) {
-          idx++;
+    public int lengthOfLIS(int[] nums) {
+        List<Integer> subsequence = new ArrayList<>();
+        subsequence.add(nums[0]);
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] > subsequence.get(subsequence.size() - 1)) {
+                subsequence.add(nums[i]);
+            } else {
+                int idx = 0;
+                while (nums[i] > subsequence.get(idx)) {
+                    idx++;
+                }
+                subsequence.set(idx, nums[i]);
+            }
         }
-        subsequence.set(idx, currNum);
-      }
+        return subsequence.size();
     }
-    return subsequence.size();
-  }
 }

From d376fe1e6c95798c21db6276c2b111909916079a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 6 Jan 2024 12:39:41 -0800
Subject: [PATCH 1900/2175] Update Maximum Profit in Job Scheduling.java

---
 Hard/Maximum Profit in Job Scheduling.java | 46 +++++++++++++++-------
 1 file changed, 32 insertions(+), 14 deletions(-)

diff --git a/Hard/Maximum Profit in Job Scheduling.java b/Hard/Maximum Profit in Job Scheduling.java
index f95e58ab..8a785d43 100644
--- a/Hard/Maximum Profit in Job Scheduling.java	
+++ b/Hard/Maximum Profit in Job Scheduling.java	
@@ -1,28 +1,46 @@
 class Solution {
     public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
-        int n = startTime.length;
+        int n = profit.length;
         int[][] jobs = new int[n][3];
         for (int i = 0; i < n; i++) {
             jobs[i] = new int[]{startTime[i], endTime[i], profit[i]};
         }
         Arrays.sort(jobs, (a, b) -> a[0] - b[0]);
-        Integer[] cache = new Integer[n];
-        return dfs(0, jobs, cache);
+        for (int i = 0; i < n; i++) {
+            startTime[i] = jobs[i][0];
+        }
+        int[] dp = new int[n + 1];
+        Arrays.fill(dp, -1);
+        return findMaxProfit(jobs, startTime, 0, n, dp);
     }
-    
-    private int dfs(int idx, int[][] jobs, Integer[] cache) {
-        if (idx == jobs.length) {
+
+    private int findMaxProfit(int[][] jobs, int[] startTime, int position, int n, int[] dp) {
+        if (position == n) {
             return 0;
         }
-        if (cache[idx] != null) {
-            return cache[idx];
+        if (dp[position] != -1) {
+            return dp[position];
         }
-        int nextIdx = idx + 1;
-        while (nextIdx < jobs.length && jobs[idx][1] > jobs[nextIdx][0]) {
-            nextIdx++;
+        int nextPosition = binarySearch(startTime, jobs[position][1]);
+        return dp[position] = Math.max(
+            findMaxProfit(jobs, startTime, position + 1, n, dp), // skip executing current job
+            jobs[position][2] + findMaxProfit(jobs, startTime, nextPosition, n, dp) // execute current job & move to next position
+        );
+    }
+
+    private static int binarySearch(int[] startTime, int endTime) {
+        int left = 0;
+        int right = startTime.length - 1;
+        int nextPosition = startTime.length;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (startTime[mid] >= endTime) {
+                nextPosition = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
         }
-        int jobScheduled = jobs[idx][2] + dfs(nextIdx, jobs, cache);
-        int jobNotScheduled = dfs(idx + 1, jobs, cache);
-        return cache[idx] = Math.max(jobScheduled, jobNotScheduled);
+        return nextPosition;
     }
 }

From 252fe13a578923364fbbd04c90e6a57ec3690051 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 7 Jan 2024 07:12:24 -0800
Subject: [PATCH 1901/2175] Create Arithmetic Slices II - Subsequence.java

---
 Hard/Arithmetic Slices II - Subsequence.java | 22 ++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Hard/Arithmetic Slices II - Subsequence.java

diff --git a/Hard/Arithmetic Slices II - Subsequence.java b/Hard/Arithmetic Slices II - Subsequence.java
new file mode 100644
index 00000000..f193579f
--- /dev/null
+++ b/Hard/Arithmetic Slices II - Subsequence.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int numberOfArithmeticSlices(int[] nums) {
+        int n = nums.length;
+        Map<Integer, Integer>[] count = new Map[n];
+        int result = 0;
+        for (int i = 0; i < n; i++) {
+            count[i] = new HashMap<>();
+            for (int j = 0; j < i; j++) {
+                long delta = ((long) nums[i]) - ((long) nums[j]);
+                if (delta < Integer.MIN_VALUE || delta > Integer.MAX_VALUE) {
+                    continue;
+                }
+                int diff = (int) delta;
+                int sum = count[j].getOrDefault(diff, 0);
+                int current = count[i].getOrDefault(diff, 0);
+                count[i].put(diff, current + sum + 1);
+                result += sum;
+            }
+        }
+        return result;
+    }
+}

From 0d7a11224ce1f94eb8d7c7792773bce5f04ea7d8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Jan 2024 08:03:57 -0800
Subject: [PATCH 1902/2175] Update Leaf-Similar Trees.java

---
 Easy/Leaf-Similar Trees.java | 32 +++++++++++++++++++-------------
 1 file changed, 19 insertions(+), 13 deletions(-)

diff --git a/Easy/Leaf-Similar Trees.java b/Easy/Leaf-Similar Trees.java
index 1ac4d480..082f6583 100644
--- a/Easy/Leaf-Similar Trees.java	
+++ b/Easy/Leaf-Similar Trees.java	
@@ -15,22 +15,28 @@
  */
 class Solution {
     public boolean leafSimilar(TreeNode root1, TreeNode root2) {
-        StringBuilder leavesOne = new StringBuilder();
-        StringBuilder leavesTwo = new StringBuilder();
-        populateLeaves(root1, leavesOne);
-        populateLeaves(root2, leavesTwo);
-        return leavesOne.toString().equals(leavesTwo.toString());
+        return getLeaves(root1).equals(getLeaves(root2));
     }
-    
-    private void populateLeaves(TreeNode root, StringBuilder leaves) {
+
+    private static List<Integer> getLeaves(TreeNode root) {
         if (root == null) {
-            return;
+            return new ArrayList<>();
         }
-        if (root.left == null && root.right == null) {
-            leaves.append(root.val).append(",");
-            return;
+        List<Integer> result = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode removed = stack.pop();
+            if (removed.left == null && removed.right == null) {
+                result.add(removed.val);
+            }
+            if (removed.right != null) {
+                stack.push(removed.right);
+            }
+            if (removed.left != null) {
+                stack.push(removed.left);
+            }
         }
-        populateLeaves(root.left, leaves);
-        populateLeaves(root.right, leaves);
+        return result;
     }
 }

From f3474fb10dea8798e8ec54960f22227fb8e8cac2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Jan 2024 17:44:14 -0800
Subject: [PATCH 1903/2175] Create Amount of Time for Binary Tree to Be
 Infected.java

---
 ...f Time for Binary Tree to Be Infected.java | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 Medium/Amount of Time for Binary Tree to Be Infected.java

diff --git a/Medium/Amount of Time for Binary Tree to Be Infected.java b/Medium/Amount of Time for Binary Tree to Be Infected.java
new file mode 100644
index 00000000..8d5540ab
--- /dev/null
+++ b/Medium/Amount of Time for Binary Tree to Be Infected.java	
@@ -0,0 +1,65 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int amountOfTime(TreeNode root, int start) {
+        Map<TreeNode, TreeNode> nodeToParent = new HashMap<>();
+        buildNodeToParentRelationship(root, null, nodeToParent);
+        TreeNode startNode = nodeToParent.keySet()
+            .stream()
+            .filter(node -> node.val == start)
+            .findFirst()
+            .orElse(null);
+        return calculateInfectionTime(nodeToParent, startNode);
+    }
+
+    private void buildNodeToParentRelationship(TreeNode root, TreeNode parent, Map<TreeNode, TreeNode> nodeToParent) {
+        if (root == null) {
+            return;
+        }
+        nodeToParent.put(root, parent);
+        buildNodeToParentRelationship(root.left, root, nodeToParent);
+        buildNodeToParentRelationship(root.right, root, nodeToParent);
+    }
+
+    private int calculateInfectionTime(Map<TreeNode, TreeNode> nodeToParent, TreeNode startNode) {
+        int time = 0;
+        Set<Integer> isInfected = new HashSet<>();
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(startNode);
+        isInfected.add(startNode.val);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                TreeNode parent = nodeToParent.get(removed);
+                if (nodeToParent.get(removed) != null && isInfected.add(nodeToParent.get(removed).val)) {
+                    queue.add(nodeToParent.get(removed));
+                }
+                if (removed.left != null && isInfected.add(removed.left.val)) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null && isInfected.add(removed.right.val)) {
+                    queue.add(removed.right);
+                }
+            }
+            if (queue.isEmpty()) {
+                break;
+            }
+            time++;
+        }
+        return time;
+    }
+}

From f7fd40e1c516f53c01658e7e4787de5f363c03f5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 12 Jan 2024 07:24:46 -0800
Subject: [PATCH 1904/2175] Update Determine if String Halves Are Alike.java

---
 .../Determine if String Halves Are Alike.java | 30 +++++++++++--------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/Easy/Determine if String Halves Are Alike.java b/Easy/Determine if String Halves Are Alike.java
index 218ce0ed..f7c9a995 100644
--- a/Easy/Determine if String Halves Are Alike.java	
+++ b/Easy/Determine if String Halves Are Alike.java	
@@ -1,14 +1,20 @@
 class Solution {
-  private static final String VOWELS = "aeiouAEIOU";
-  public boolean halvesAreAlike(String s) {
-    return getVowelCount(s.substring(0, s.length() / 2)).equals(getVowelCount(s.substring(s.length() / 2)));
-  }
-  
-  private Long getVowelCount(String s) {
-    return s.chars().mapToObj(c -> (char) c).filter(Solution::isVowel).count();
-  }
-  
-  private static boolean isVowel(char c) {
-    return VOWELS.indexOf(c) != -1;
-  }
+
+    private static final Set<Character> VOWELS = Set.of(
+        'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'
+    );
+
+    public boolean halvesAreAlike(String s) {
+        int count = 0;
+        int n = s.length();
+        for (int i = 0; i < n / 2; i++) {
+            if (VOWELS.contains(s.charAt(i))) {
+                count++;
+            }
+            if (VOWELS.contains(s.charAt(i + n / 2))) {
+                count--;
+            }
+        }
+        return count == 0;
+    }
 }

From d00ccb6645f0e465f2b504340b622a28b4091fcc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 14 Jan 2024 08:28:46 -0800
Subject: [PATCH 1905/2175] Update Determine if Two Strings Are Close.java

---
 .../Determine if Two Strings Are Close.java   | 52 +++++++++----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/Medium/Determine if Two Strings Are Close.java b/Medium/Determine if Two Strings Are Close.java
index 96a5181a..3a43fd6a 100644
--- a/Medium/Determine if Two Strings Are Close.java	
+++ b/Medium/Determine if Two Strings Are Close.java	
@@ -1,30 +1,30 @@
 class Solution {
-  public boolean closeStrings(String word1, String word2) {
-    if (word1.length() != word2.length()) {
-      return false;
+    public boolean closeStrings(String word1, String word2) {
+        if (word1.length() != word2.length()) {
+            return false;
+        }
+        int[] frequencyOne = getFrequencyArray(word1);
+        int[] frequencyTwo = getFrequencyArray(word2);
+        for (int i = 0; i < 26; i++) {
+            if (frequencyOne[i] == 0 && frequencyTwo[i] != 0) {
+                return false;
+            }
+        }
+        Arrays.sort(frequencyOne);
+        Arrays.sort(frequencyTwo);
+        for (int i = 0; i < 26; i++) {
+            if (frequencyOne[i] != frequencyTwo[i]) {
+                return false;
+            }
+        }
+        return true;
     }
-    int[] frequencyOne = getFrequencyArray(word1);
-    int[] frequencyTwo = getFrequencyArray(word2);
-    for (int i = 0; i < frequencyOne.length; i++) {
-      if (frequencyOne[i] == 0 && frequencyTwo[i] != 0) {
-        return false;
-      }
+
+    private static int[] getFrequencyArray(String s) {
+        int[] frequency = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            frequency[s.charAt(i) - 'a']++;
+        }
+        return frequency;
     }
-    Arrays.sort(frequencyOne);
-    Arrays.sort(frequencyTwo);
-    for (int i = 0; i < frequencyOne.length; i++) {
-      if (frequencyOne[i] != frequencyTwo[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  
-  private int[] getFrequencyArray(String s) {
-    int[] frequency = new int[26];
-    for (char c : s.toCharArray()) {
-      frequency[c - 'a']++;
-    }
-    return frequency;
-  }
 }

From 17c91bf727afa5efbf612dc66c3b408392cc74d2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 Jan 2024 08:05:08 -0800
Subject: [PATCH 1906/2175] Update Find Players With Zero or One Losses.java

---
 .../Find Players With Zero or One Losses.java | 40 +++++++++----------
 1 file changed, 19 insertions(+), 21 deletions(-)

diff --git a/Medium/Find Players With Zero or One Losses.java b/Medium/Find Players With Zero or One Losses.java
index f3f14ff5..1692f1e5 100644
--- a/Medium/Find Players With Zero or One Losses.java	
+++ b/Medium/Find Players With Zero or One Losses.java	
@@ -1,24 +1,22 @@
 class Solution {
-  public List<List<Integer>> findWinners(int[][] matches) {
-    Map<Integer, Integer> lossCount = new HashMap<>();
-    Set<Integer> players = new HashSet<>();
-    for (int[] match : matches) {
-      lossCount.put(match[1], lossCount.getOrDefault(match[1], 0) + 1);
-      players.add(match[0]);
-      players.add(match[1]);
+    public List<List<Integer>> findWinners(int[][] matches) {
+        Map<Integer, Integer> playerToLossCount = new HashMap<>();
+        for (int[] match : matches) {
+            int winner = match[0];
+            int loser = match[1];
+            playerToLossCount.putIfAbsent(winner, 0);
+            playerToLossCount.put(loser, playerToLossCount.getOrDefault(loser, 0) + 1);
+        }
+        List<List<Integer>> result = new ArrayList<>(
+            Arrays.asList(new ArrayList<>(), new ArrayList<>())
+        );
+        for (Map.Entry<Integer, Integer> entry : playerToLossCount.entrySet()) {
+            if (entry.getValue() <= 1) {
+                result.get(entry.getValue()).add(entry.getKey());
+            }
+        }
+        Collections.sort(result.get(0));
+        Collections.sort(result.get(1));
+        return result;
     }
-    List<Integer> noLoss = new ArrayList<>();
-    List<Integer> exactlyOneLoss = new ArrayList<>();
-    for (Integer player : players) {
-      if (!lossCount.containsKey(player)) {
-        noLoss.add(player);
-      }
-      if (lossCount.getOrDefault(player, 0) == 1) {
-        exactlyOneLoss.add(player);
-      }
-    }
-    Collections.sort(noLoss);
-    Collections.sort(exactlyOneLoss);
-    return Arrays.asList(noLoss, exactlyOneLoss);
-  }
 }

From 290f75fa9e8d3840aeafc27141b7dd7000225c12 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 15 Jan 2024 13:13:06 -0800
Subject: [PATCH 1907/2175] Update Single-Row Keyboard.java

---
 Easy/Single-Row Keyboard.java | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/Easy/Single-Row Keyboard.java b/Easy/Single-Row Keyboard.java
index 5a59a1d6..f09a641c 100644
--- a/Easy/Single-Row Keyboard.java	
+++ b/Easy/Single-Row Keyboard.java	
@@ -1,16 +1,15 @@
 class Solution {
-  public int calculateTime(String keyboard, String word) {
-    Map<Character, Integer> map = new HashMap<>();
-    int pos = 0;
-    for (char c : keyboard.toCharArray()) {
-      map.put(c, pos++);
+    public int calculateTime(String keyboard, String word) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < 26; i++) {
+            map.put(keyboard.charAt(i), i);
+        }
+        int position = 0;
+        int time = 0;
+        for (char c : word.toCharArray()) {
+            time += Math.abs(position - map.get(c));
+            position = map.get(c);
+        }
+        return time;
     }
-    int total = 0;
-    int currPos = 0;
-    for (char c : word.toCharArray()) {
-      total += Math.abs(currPos - map.get(c));
-      currPos = map.get(c);
-    }
-    return total;
-  }
 }

From 509b60fc8bb7ab11209af0cb4da088432b40679c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 16 Jan 2024 08:02:23 -0800
Subject: [PATCH 1908/2175] Update Insert Delete GetRandom O(1).java

---
 Medium/Insert Delete GetRandom O(1).java | 61 ++++++++++++------------
 1 file changed, 31 insertions(+), 30 deletions(-)

diff --git a/Medium/Insert Delete GetRandom O(1).java b/Medium/Insert Delete GetRandom O(1).java
index 3b9b44ae..9ef0fc92 100644
--- a/Medium/Insert Delete GetRandom O(1).java	
+++ b/Medium/Insert Delete GetRandom O(1).java	
@@ -1,40 +1,41 @@
 class RandomizedSet {
 
-  private List<Integer> randomizedSet;
-  private Map<Integer, Integer> indexMap;
-  private int currSize;
-  
-  public RandomizedSet() {
-    this.randomizedSet = new ArrayList<>();
-    this.indexMap = new HashMap<>();
-    this.currSize = 0;
-  }
+    private final List<Integer> values;
+    private final Map<Integer, Integer> valToIndexMap;
 
-  public boolean insert(int val) {
-    if (this.indexMap.containsKey(val)) {
-      return false;
+    public RandomizedSet() {
+        this.values = new ArrayList<>();
+        this.valToIndexMap = new HashMap<>();
     }
-    this.randomizedSet.add(val);
-    this.indexMap.put(val, this.currSize++);
-    return true;
-  }
 
-  public boolean remove(int val) {
-    if (!this.indexMap.containsKey(val)) {
-      return false;
+    public boolean insert(int val) {
+        if (valToIndexMap.containsKey(val)) {
+            return false;
+        }
+        values.add(val);
+        valToIndexMap.put(val, values.size() - 1);
+        return true;
     }
-    int valIdx = this.indexMap.get(val);
-    this.indexMap.put(this.randomizedSet.get(this.currSize - 1), valIdx);
-    this.randomizedSet.set(valIdx, this.randomizedSet.get(this.currSize - 1));
-    this.randomizedSet.remove(this.currSize - 1);
-    this.indexMap.remove(val);
-    this.currSize--;
-    return true;
-  }
 
-  public int getRandom() {
-    return this.randomizedSet.get(new Random().nextInt(this.currSize));
-  }
+    public boolean remove(int val) {
+        if (!valToIndexMap.containsKey(val)) {
+            return false;
+        }
+        int valIdx = valToIndexMap.get(val);
+        int valAtLastIdx = values.get(values.size() - 1);
+        // update index for last element
+        values.set(valIdx, valAtLastIdx);
+        valToIndexMap.put(valAtLastIdx, valIdx);
+        // remove value
+        values.remove(values.size() - 1);
+        valToIndexMap.remove(val);
+        return true;
+    }
+
+    public int getRandom() {
+        int idx = new Random().nextInt(values.size());
+        return values.get(idx);
+    }
 }
 
 /**

From cb64d7eb820a18aabb0569c53cf9bfa56e9d81a7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 18 Jan 2024 07:55:19 -0800
Subject: [PATCH 1909/2175] Update Climbing Stairs.java

---
 Easy/Climbing Stairs.java | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/Easy/Climbing Stairs.java b/Easy/Climbing Stairs.java
index f2ff9386..ad49acda 100644
--- a/Easy/Climbing Stairs.java	
+++ b/Easy/Climbing Stairs.java	
@@ -1,14 +1,19 @@
 class Solution {
-  public int climbStairs(int n) {
-    if (n == 1) {
-      return 1;
+    public int climbStairs(int n) {
+        Integer[] dp = new Integer[n + 1];
+        return climbStairs(dp, n);
     }
-    int[] dp = new int[n + 1];
-    dp[1] = 1;
-    dp[2] = 2;
-    for (int i = 3; i <= n; i++) {
-      dp[i] = dp[i - 1] + dp[i - 2];
+
+    private int climbStairs(Integer[] dp, int n) {
+        if (n == 1) {
+            return 1;
+        }
+        if (n == 2) {
+            return 2;
+        }
+        if (dp[n] != null) {
+            return dp[n];
+        }
+        return dp[n] = climbStairs(dp, n - 1) + climbStairs(dp, n - 2);
     }
-    return dp[n];
-  }
 }

From 8c794995f324ad1bc8e7a92673ce2e24af14c2a5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 19 Jan 2024 09:12:22 -0800
Subject: [PATCH 1910/2175] Update Minimum Falling Path Sum.java

---
 Medium/Minimum Falling Path Sum.java | 52 ++++++++++++++++------------
 1 file changed, 29 insertions(+), 23 deletions(-)

diff --git a/Medium/Minimum Falling Path Sum.java b/Medium/Minimum Falling Path Sum.java
index 040759bf..255081b9 100644
--- a/Medium/Minimum Falling Path Sum.java	
+++ b/Medium/Minimum Falling Path Sum.java	
@@ -1,27 +1,33 @@
 class Solution {
-  public int minFallingPathSum(int[][] matrix) {
-    int minFallingSum = Integer.MAX_VALUE;
-    Integer[][] dp = new Integer[matrix.length][matrix[0].length];
-    for (int i = 0; i < matrix.length; i++) {
-      minFallingSum = Math.min(minFallingSum, findMinFallingPathSumHelper(matrix, 0, i, dp));
+    private static final int[][] DIRS = {{1, -1}, {1, 0}, {1, 1}};
+
+    public int minFallingPathSum(int[][] matrix) {
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+        Integer[][] dp = new Integer[rows + 1][cols + 1];
+        int result = Integer.MAX_VALUE;
+        for (int i = 0; i < cols; i++) {
+            result = Math.min(result, recurse(matrix, 0, i, rows, cols, dp));
+        }
+        return result;
     }
-    return minFallingSum;
-  }
-  
-  private int findMinFallingPathSumHelper(int[][] matrix, int row, int col, Integer[][] dp) {
-    if (col < 0 || col == matrix.length) {
-      return Integer.MAX_VALUE;
+
+    private int recurse(int[][] matrix, int row, int col, int rows, int cols, Integer[][] dp) {
+        if (row == rows - 1) {
+            return matrix[row][col];
+        }
+        if (dp[row][col] != null) {
+            return dp[row][col];
+        }
+        int result = Integer.MAX_VALUE;
+        for (int[] dir : DIRS) {
+            int newRow = row + dir[0];
+            int newCol = col + dir[1];
+            if (newRow < 0 || newCol < 0 || newRow >= rows || newCol >= cols) {
+                continue;
+            }
+            result = Math.min(result, matrix[row][col] + recurse(matrix, newRow, newCol, rows, cols, dp));
+        }
+        return dp[row][col] = result;
     }
-    if (row == matrix.length - 1) {
-      return matrix[row][col];
-    }
-    if (dp[row][col] != null) {
-      return dp[row][col];
-    }
-    int leftSum = findMinFallingPathSumHelper(matrix, row + 1, col, dp);
-    int middleSum = findMinFallingPathSumHelper(matrix, row + 1, col + 1, dp);
-    int rightSum = findMinFallingPathSumHelper(matrix, row + 1, col - 1, dp);
-    dp[row][col] = Math.min(leftSum, Math.min(middleSum, rightSum)) + matrix[row][col];
-    return dp[row][col];
-  }
 }

From acd2e4ea9cbead40873afc7eec9643986ec7df85 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Jan 2024 08:32:44 -0800
Subject: [PATCH 1911/2175] Create Divide an Array Into Subarrays With Minimum
 Cost I.java

---
 ... Array Into Subarrays With Minimum Cost I.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Divide an Array Into Subarrays With Minimum Cost I.java

diff --git a/Easy/Divide an Array Into Subarrays With Minimum Cost I.java b/Easy/Divide an Array Into Subarrays With Minimum Cost I.java
new file mode 100644
index 00000000..7b214fa7
--- /dev/null
+++ b/Easy/Divide an Array Into Subarrays With Minimum Cost I.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int minimumCost(int[] nums) {
+        int minOne = Integer.MAX_VALUE;
+        int minTwo = Integer.MAX_VALUE;
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] < minOne) {
+                minTwo = minOne;
+                minOne = nums[i];
+            } else if (nums[i] < minTwo) {
+                minTwo = nums[i];
+            }
+        }
+        return nums[0] + minOne + minTwo;
+    }
+}

From 640cd980c384f2891851638cf30b5949f828e4d0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Jan 2024 08:39:26 -0800
Subject: [PATCH 1912/2175] Create Count Elements With Maximum Frequency.java

---
 Easy/Count Elements With Maximum Frequency.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Count Elements With Maximum Frequency.java

diff --git a/Easy/Count Elements With Maximum Frequency.java b/Easy/Count Elements With Maximum Frequency.java
new file mode 100644
index 00000000..0f023200
--- /dev/null
+++ b/Easy/Count Elements With Maximum Frequency.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxFrequencyElements(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int maxFrequency = 0;
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+            maxFrequency = Math.max(maxFrequency, map.get(num));
+        }
+        int count = 0;
+        for (int num : nums) {
+            if (map.get(num) == maxFrequency) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

From eb1a80cf33928453335bcee28120011da2d80654 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Jan 2024 09:18:41 -0800
Subject: [PATCH 1913/2175] Update House Robber.java

---
 Medium/House Robber.java | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/Medium/House Robber.java b/Medium/House Robber.java
index 8837a99d..3ebdc59b 100644
--- a/Medium/House Robber.java	
+++ b/Medium/House Robber.java	
@@ -1,14 +1,11 @@
 class Solution {
-  public int rob(int[] nums) {
-    if (nums.length == 1) {
-      return nums[0];
+    public int rob(int[] nums) {
+        int n = nums.length;
+        int[] dp = new int[n + 1];
+        dp[1] = nums[0];
+        for (int i = 1; i < n; i++) {
+            dp[i + 1] = Math.max(dp[i], dp[i - 1] + nums[i]);
+        }
+        return dp[n];
     }
-    int[] dp = new int[nums.length];
-    dp[0] = nums[0];
-    dp[1] = Math.max(nums[0], nums[1]);
-    for (int i = 2; i < nums.length; i++) {
-      dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
-    }
-    return dp[nums.length - 1];
-  }
 }

From c674418fc8b72aa72b59557cb3541841d2b70b72 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Jan 2024 18:07:48 -0800
Subject: [PATCH 1914/2175] Update Set Mismatch.java

---
 Easy/Set Mismatch.java | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/Easy/Set Mismatch.java b/Easy/Set Mismatch.java
index 9660688d..eac82238 100644
--- a/Easy/Set Mismatch.java	
+++ b/Easy/Set Mismatch.java	
@@ -1,18 +1,19 @@
 class Solution {
-  public int[] findErrorNums(int[] nums) {
-    int[] result = new int[2];
-    Set<Integer> set = new HashSet<>();
-    int n = nums.length;
-    for (int num : nums) {
-      if (!set.add(num)) {
-        result[0] = num;
-      }
+    public int[] findErrorNums(int[] nums) {
+        int n = nums.length;
+        int[] result = new int[2];
+        Set<Integer> set = new HashSet<>();
+        for (int i = 1; i <= n; i++) {
+            if (!set.add(nums[i - 1])) {
+                result[0] = nums[i - 1];
+            }
+        }
+        for (int i = 1; i <= n; i++) {
+            if (!set.contains(i)) {
+                result[1] = i;
+                break;
+            }
+        }
+        return result;
     }
-    for (int i = 1; i <= n; i++) {
-      if (!set.contains(i)) {
-        result[1] = i;
-      }
-    }
-    return result;
-  }
 }

From 1c8632fdf47f5a2ef31fc1208399bd3a15a25e83 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Jan 2024 09:24:10 -0800
Subject: [PATCH 1915/2175] Create Minimum Number of Pushes to Type Word I.java

---
 Easy/Minimum Number of Pushes to Type Word I.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Minimum Number of Pushes to Type Word I.java

diff --git a/Easy/Minimum Number of Pushes to Type Word I.java b/Easy/Minimum Number of Pushes to Type Word I.java
new file mode 100644
index 00000000..0a6bbc24
--- /dev/null
+++ b/Easy/Minimum Number of Pushes to Type Word I.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int minimumPushes(String word) {
+        int pushes = 0;
+        int idx = 0;
+        int multiple = 1;
+        while (idx < word.length()) {
+            int count = Math.min(8, word.length() - idx);
+            pushes += count * multiple;
+            multiple++;
+            idx += count;
+        }
+        return pushes;
+    }
+}

From 828c46fe3336aae41adfd56827c01a4f72d424f7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Jan 2024 18:47:26 -0800
Subject: [PATCH 1916/2175] Create Maximum Length of a Concatenated String with
 Unique Characters.java

---
 ...tenated String with Unique Characters.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Maximum Length of a Concatenated String with Unique Characters.java

diff --git a/Medium/Maximum Length of a Concatenated String with Unique Characters.java b/Medium/Maximum Length of a Concatenated String with Unique Characters.java
new file mode 100644
index 00000000..65ca06dc
--- /dev/null
+++ b/Medium/Maximum Length of a Concatenated String with Unique Characters.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int maxLength(List<String> arr) {
+        return backtrack(arr, 0, new HashMap<>());
+    }
+
+    private int backtrack(List<String> arr, int idx, Map<Character, Integer> map) {
+        if (map.values().stream().anyMatch(val -> val > 1)) {
+            return 0;
+        }
+        int result = map.size();
+        for (int i = idx; i < arr.size(); i++) {
+            char[] chars = arr.get(i).toCharArray();
+            for (char c : chars) {
+                map.put(c, map.getOrDefault(c, 0) + 1);
+            }
+            result = Math.max(result, backtrack(arr, i + 1, map));
+            for (char c : chars) {
+                map.put(c, map.get(c) - 1);
+                if (map.get(c) == 0) {
+                    map.remove(c);
+                }
+            }
+        }
+        return result;
+    }
+}

From 6b0aba9576f5f097cd78ef11144be0b9617c875b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 24 Jan 2024 07:01:26 -0800
Subject: [PATCH 1917/2175] Update Pseudo-Palindromic Paths in a Binary
 Tree.java

---
 ...do-Palindromic Paths in a Binary Tree.java | 65 +++++++++----------
 1 file changed, 30 insertions(+), 35 deletions(-)

diff --git a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java
index 04cbe822..87acbbf4 100644
--- a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java	
+++ b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java	
@@ -14,43 +14,38 @@
  * }
  */
 class Solution {
-  public int pseudoPalindromicPaths (TreeNode root) {
-    Queue<NodePathPair> queue = new LinkedList<>();
-    NodePathPair nodePathPair = new NodePathPair(root, 0);
-    queue.add(nodePathPair);
-    int count = 0;
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        NodePathPair removed = queue.remove();
-        TreeNode node = removed.node;
-        int path = removed.path;
-        // XOR operation ensures that the bit corresponding to the number only appears in the
-        // path if it has occurred odd number of times. 
-        // 1 << node.val decides the bit of the value
-        path = path ^ (1 << node.val);
-        if (node.left == null && node.right == null) {
-          // Subtracting 1 means setting rightmost 1 bit to 0 and setting all lower bits to 1
-          count += (path & (path - 1)) == 0 ? 1 : 0;
-        } 
-        if (node.left != null) {
-          queue.add(new NodePathPair(node.left, path));
+    public int pseudoPalindromicPaths (TreeNode root) {
+        int[] result = {0};
+        Map<Integer, Integer> map = new HashMap<>();
+        helper(root, map, result);
+        return result[0];
+    }
+
+    private void helper(TreeNode root, Map<Integer, Integer> map, int[] result) {
+        if (root == null) {
+            return;
         }
-        if (node.right != null) {
-          queue.add(new NodePathPair(node.right, path));
+        map.put(root.val, map.getOrDefault(root.val, 0) + 1);
+        if (root.left == null && root.right == null) {
+            if (isPseudoPalindromic(map)) {
+                result[0]++;
+            }
         }
-      }
+        helper(root.left, map, result);
+        helper(root.right, map, result);
+        map.put(root.val, map.getOrDefault(root.val, 0) - 1);
     }
-    return count;
-  }
-  
-  private static class NodePathPair {
-    TreeNode node;
-    Integer path;
-    
-    public NodePathPair(TreeNode node, int path) {
-      this.node = node;
-      this.path = path;
+
+    private static boolean isPseudoPalindromic(Map<Integer, Integer> map) {
+        boolean oddFound = false;
+        for (Integer key : map.keySet()) {
+            if (map.get(key) % 2 != 0) {
+                if (oddFound) {
+                    return false;
+                }
+                oddFound = true;
+            }
+        }
+        return true;
     }
-  }
 }

From 0d3ab9b8f111e098b98e89b8c2ea28ec69a71f14 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 25 Jan 2024 07:25:30 -0800
Subject: [PATCH 1918/2175] Create Longest Common Subsequence.java

---
 Medium/Longest Common Subsequence.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Longest Common Subsequence.java

diff --git a/Medium/Longest Common Subsequence.java b/Medium/Longest Common Subsequence.java
new file mode 100644
index 00000000..43fc5464
--- /dev/null
+++ b/Medium/Longest Common Subsequence.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int longestCommonSubsequence(String text1, String text2) {
+        int n = text1.length();
+        int m = text2.length();
+        int[][] dp = new int[n + 1][m + 1];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (text1.charAt(i) == text2.charAt(j)) {
+                    dp[i + 1][j + 1] = 1 + dp[i][j];
+                } else {
+                    dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+                }
+            }
+        }
+        return dp[n][m];
+    }
+}

From 740bcab2ec19b8021bbf58b3c9b59bc21112df17 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 26 Jan 2024 07:06:02 -0800
Subject: [PATCH 1919/2175] Update Out of Boundary Paths.java

---
 Medium/Out of Boundary Paths.java | 52 +++++++++++++------------------
 1 file changed, 22 insertions(+), 30 deletions(-)

diff --git a/Medium/Out of Boundary Paths.java b/Medium/Out of Boundary Paths.java
index 7179a63c..fc7e9a26 100644
--- a/Medium/Out of Boundary Paths.java	
+++ b/Medium/Out of Boundary Paths.java	
@@ -1,34 +1,26 @@
 class Solution {
-  private final int MODULUS = 1000000000 + 7;
-  
-  public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
-    int dp[][] = new int[m][n];
-    dp[startRow][startColumn] = 1;
-    int count = 0;
-    for (int currMove = 1; currMove <= maxMove; currMove++) {
-      int[][] temp = new int[m][n];
-      for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-          if (i == m - 1) {
-            count = (count + dp[i][j]) % MODULUS;
-          }
-          if (j == n - 1) {
-            count = (count + dp[i][j]) % MODULUS;
-          }
-          if (i == 0) {
-            count = (count + dp[i][j]) % MODULUS;
-          }
-          if (j == 0) {
-            count = (count + dp[i][j]) % MODULUS;
-          }
-          temp[i][j] = (
-              ((i > 0 ? dp[i - 1][j] : 0) + (i < m - 1 ? dp[i + 1][j] : 0)) % MODULUS +
-              ((j > 0 ? dp[i][j - 1] : 0) + (j < n - 1 ? dp[i][j + 1] : 0)) % MODULUS
-          ) % MODULUS;
+
+    private static final int MOD = 1000_000_007;
+
+    public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
+        Integer[][][] dp = new Integer[m][n][maxMove + 1];
+        return findPaths(m, n, maxMove, startRow, startColumn, dp);
+    }
+
+    public int findPaths(int m, int n, int maxMove, int startRow, int startColumn, Integer[][][] dp) {
+        if (startRow == m || startColumn == n || startRow < 0 || startColumn < 0) {
+            return 1;
+        }
+        if (maxMove == 0) {
+            return 0;
+        }
+        if (dp[startRow][startColumn][maxMove] != null) {
+            return dp[startRow][startColumn][maxMove];
         }
-      }
-      dp = temp;
+        return dp[startRow][startColumn][maxMove] = (
+            (findPaths(m, n, maxMove - 1, startRow - 1, startColumn, dp) +
+            findPaths(m, n, maxMove - 1, startRow + 1, startColumn, dp)) % MOD +
+            (findPaths(m, n, maxMove - 1, startRow, startColumn - 1, dp) +
+            findPaths(m, n, maxMove - 1, startRow, startColumn + 1, dp)) % MOD) % MOD; 
     }
-    return count;
-  }
 }

From 3291f2ecc3947705ee3e6fd6247f5326b315c6bf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 27 Jan 2024 12:00:40 -0800
Subject: [PATCH 1920/2175] Create Find if Array Can Be Sorted.java

---
 Medium/Find if Array Can Be Sorted.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Find if Array Can Be Sorted.java

diff --git a/Medium/Find if Array Can Be Sorted.java b/Medium/Find if Array Can Be Sorted.java
new file mode 100644
index 00000000..8b08e457
--- /dev/null
+++ b/Medium/Find if Array Can Be Sorted.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean canSortArray(int[] nums) {
+        int lastGroupHighest = 0;
+        int highest = nums[0];
+        boolean bitChange = false;
+        for (int i = 1; i < nums.length; i++) {
+            bitChange = Integer.bitCount(highest) != Integer.bitCount(nums[i]);
+            if (bitChange) {
+                lastGroupHighest = highest;
+            }
+            highest = Math.max(nums[i], highest);
+            if (nums[i] < lastGroupHighest) {
+                return false;
+            }
+        } 
+        return true;
+    }
+}

From 3809df81774e8b2715db2718caf40fd11d2f111c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Jan 2024 14:58:26 -0800
Subject: [PATCH 1921/2175] Create Number of Changing Keys.java

---
 Easy/Number of Changing Keys.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Number of Changing Keys.java

diff --git a/Easy/Number of Changing Keys.java b/Easy/Number of Changing Keys.java
new file mode 100644
index 00000000..bb6bc939
--- /dev/null
+++ b/Easy/Number of Changing Keys.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int countKeyChanges(String s) {
+        int changes = 0;
+        for (int i = 1; i < s.length(); i++) {
+            if (Character.toLowerCase(s.charAt(i)) != Character.toLowerCase(s.charAt(i - 1))) {
+                changes++;
+            }
+        }
+        return changes;
+    }
+}

From f3af4a0a7924a50f74f90bc28f6d311f54ba2401 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 29 Jan 2024 07:14:19 -0800
Subject: [PATCH 1922/2175] Update Implement Queue using Stacks.java

---
 Easy/Implement Queue using Stacks.java | 38 +++++++++++++-------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/Easy/Implement Queue using Stacks.java b/Easy/Implement Queue using Stacks.java
index fd2b165e..a84da8b6 100644
--- a/Easy/Implement Queue using Stacks.java	
+++ b/Easy/Implement Queue using Stacks.java	
@@ -1,38 +1,38 @@
 class MyQueue {
-    
-    private final Stack<Integer> stackOne;
-    private final Stack<Integer> stackTwo;
+
+    private final Stack<Integer> first;
+    private final Stack<Integer> second;
 
     public MyQueue() {
-        this.stackOne = new Stack<>();
-        this.stackTwo = new Stack<>();
+        this.first = new Stack<>();
+        this.second = new Stack<>();
     }
     
     public void push(int x) {
-        this.stackOne.push(x);
+        first.push(x);
     }
     
     public int pop() {
-        exchangeElements(stackOne, stackTwo);
-        int popped = stackTwo.pop();
-        exchangeElements(stackTwo, stackOne);
-        return popped;
+        move(first, second);
+        int result = second.pop();
+        move(second, first);
+        return result;
     }
     
     public int peek() {
-        exchangeElements(stackOne, stackTwo);
-        int peeked = stackTwo.peek();
-        exchangeElements(stackTwo, stackOne);
-        return peeked;
+        move(first, second);
+        int result = second.peek();
+        move(second, first);
+        return result;
     }
     
     public boolean empty() {
-        return stackOne.isEmpty();
+        return first.isEmpty();
     }
-    
-    private void exchangeElements(Stack<Integer> stack1, Stack<Integer> stack2) {
-        while (!stack1.isEmpty()) {
-            stack2.push(stack1.pop());
+
+    private void move(Stack<Integer> from, Stack<Integer> to) {
+        while (!from.isEmpty()) {
+            to.push(from.pop());
         }
     }
 }

From 68968bac1eeeb4e0f24937c271095903740c072a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 29 Jan 2024 11:35:45 -0800
Subject: [PATCH 1923/2175] Create Find the Maximum Number of Elements in
 Subset.java

---
 ... Maximum Number of Elements in Subset.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Find the Maximum Number of Elements in Subset.java

diff --git a/Medium/Find the Maximum Number of Elements in Subset.java b/Medium/Find the Maximum Number of Elements in Subset.java
new file mode 100644
index 00000000..4c419cbc
--- /dev/null
+++ b/Medium/Find the Maximum Number of Elements in Subset.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maximumLength(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        int result = map.containsKey(1) ? (map.get(1) % 2 == 0 ? map.get(1) - 1 : map.get(1)) : 1;
+        for (int num : nums) {
+            int count = 0;
+            while (map.containsKey(num) && map.get(num) >= 2 && num != 1) {
+                count += 2;
+                num *= num;
+            }
+            count += map.containsKey(num) ? 1 : -1;
+            result = Math.max(result, count);
+        }
+        return result;
+    }
+}

From 51add04ec8213bdf8e559dc13e9acc2abfe613a3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 30 Jan 2024 11:28:23 -0800
Subject: [PATCH 1924/2175] Update and rename Paint House.java to Paint
 House.java

---
 Easy/Paint House.java   | 18 ------------------
 Medium/Paint House.java | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 18 deletions(-)
 delete mode 100644 Easy/Paint House.java
 create mode 100644 Medium/Paint House.java

diff --git a/Easy/Paint House.java b/Easy/Paint House.java
deleted file mode 100644
index 797243d2..00000000
--- a/Easy/Paint House.java	
+++ /dev/null
@@ -1,18 +0,0 @@
-class Solution {
-    public int minCost(int[][] costs) {
-        if (costs.length == 0) {
-            return 0;
-        }
-        
-        for (int i=1; i<costs.length; i++) {
-            costs[i][0] = costs[i][0] + Math.min(costs[i-1][1], costs[i-1][2]);
-            costs[i][1] = costs[i][1] + Math.min(costs[i-1][0], costs[i-1][2]);
-            costs[i][2] = costs[i][2] + Math.min(costs[i-1][1], costs[i-1][0]);
-        }
-        
-        int idx = costs.length - 1;
-        int minCost = costs[idx][0];
-        
-        return Math.min(costs[idx][0], Math.min(costs[idx][1], costs[idx][2]));
-    }
-}
diff --git a/Medium/Paint House.java b/Medium/Paint House.java
new file mode 100644
index 00000000..27b1a502
--- /dev/null
+++ b/Medium/Paint House.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int minCost(int[][] costs) {
+        int n = costs.length;
+        int[][] dp = new int[n][3];
+        dp[0][0] = costs[0][0];
+        dp[0][1] = costs[0][1];
+        dp[0][2] = costs[0][2];
+        for (int i = 1; i < n; i++) {
+            dp[i][0] = Math.min(dp[i - 1][1], dp[i - 1][2]) + costs[i][0];
+            dp[i][1] = Math.min(dp[i - 1][0], dp[i - 1][2]) + costs[i][1];
+            dp[i][2] = Math.min(dp[i - 1][0], dp[i - 1][1]) + costs[i][2];
+        }
+        return Math.min(dp[n - 1][0], Math.min(dp[n - 1][1], dp[n - 1][2]));
+    }
+}

From a55f997ae2efba4c176623b6664f35c69a17f3dd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 30 Jan 2024 17:33:11 -0800
Subject: [PATCH 1925/2175] Update Daily Temperatures.java

---
 Medium/Daily Temperatures.java | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/Medium/Daily Temperatures.java b/Medium/Daily Temperatures.java
index ce3bdca3..5189f7ee 100644
--- a/Medium/Daily Temperatures.java	
+++ b/Medium/Daily Temperatures.java	
@@ -1,14 +1,15 @@
 class Solution {
-  public int[] dailyTemperatures(int[] T) {
-    Stack<Integer> stack = new Stack<>();
-    int[] ans = new int[T.length];
-    for (int i = T.length - 1; i >= 0; i--) {
-      while (!stack.isEmpty() && T[stack.peek()] <= T[i]) {
-        stack.pop();
-      }
-      ans[i] = stack.isEmpty() ? 0 : (stack.peek() - i);
-      stack.push(i);
+    public int[] dailyTemperatures(int[] temperatures) {
+        int n = temperatures.length;
+        int[] result = new int[n];
+        Stack<Integer> stack = new Stack<>();
+        for (int i = n - 1; i >= 0; i--) {
+            while (!stack.isEmpty() && temperatures[i] >= temperatures[stack.peek()]) {
+                stack.pop();
+            }
+            result[i] = stack.isEmpty() ? 0 : stack.peek() - i;
+            stack.push(i);
+        }
+        return result;
     }
-    return ans;
-  }
 }

From ee38423f1584b5428766a8139ea1cf767951955e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 1 Feb 2024 15:45:24 -0800
Subject: [PATCH 1926/2175] Update Flip Game.java

---
 Easy/Flip Game.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Easy/Flip Game.java b/Easy/Flip Game.java
index 75a364a0..097acf18 100644
--- a/Easy/Flip Game.java	
+++ b/Easy/Flip Game.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public List<String> generatePossibleNextMoves(String currentState) {
-    List<String> list = new ArrayList<>();
-    for (int i = 1; i < currentState.length(); i++) {
-      if (currentState.charAt(i) == '+' && currentState.charAt(i - 1) == '+') {
-        list.add(currentState.substring(0, i - 1) + "--" + currentState.substring(i + 1));
-      }
+    public List<String> generatePossibleNextMoves(String currentState) {
+        List<String> moves = new ArrayList<>();
+        for (int i = 0; i < currentState.length() - 1; i++) {
+            if (currentState.substring(i, i + 2).equals("++")) {
+                moves.add(currentState.substring(0, i) + "--" + currentState.substring(i + 2));
+            }
+        }
+        return moves;
     }
-    return list;
-  }
 }

From ba9744b0007d0636891813045a159536116d9052 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Feb 2024 09:22:23 -0800
Subject: [PATCH 1927/2175] Create Partition Array for Maximum Sum.java

---
 Medium/Partition Array for Maximum Sum.java | 25 +++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Partition Array for Maximum Sum.java

diff --git a/Medium/Partition Array for Maximum Sum.java b/Medium/Partition Array for Maximum Sum.java
new file mode 100644
index 00000000..4868c1c3
--- /dev/null
+++ b/Medium/Partition Array for Maximum Sum.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int maxSumAfterPartitioning(int[] arr, int k) {
+        Integer[] dp = new Integer[arr.length];
+        return maxSum(arr, k, dp, 0);
+    }
+
+    private int maxSum(int[] arr, int k, Integer[] dp, int start) {
+        int n = arr.length;
+        if (start >= n) {
+            return 0;
+        }
+        if (dp[start] != null) {
+            return dp[start];
+        }
+        int currMax = 0;
+        int result = 0;
+        int end = Math.min(n, start + k);
+        for (int i = start; i < end; i++) {
+            currMax = Math.max(currMax, arr[i]);
+            result = Math.max(result, 
+                currMax * (i - start + 1) + maxSum(arr, k, dp, i + 1));
+        }
+        return dp[start] = result;
+    }
+}

From 3d8dca2a27d18271fcf80f80b6de4b20c3be03d8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Feb 2024 09:30:43 -0800
Subject: [PATCH 1928/2175] Create Type of Triangle II.java

---
 Easy/Type of Triangle II.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Type of Triangle II.java

diff --git a/Easy/Type of Triangle II.java b/Easy/Type of Triangle II.java
new file mode 100644
index 00000000..09f0cb88
--- /dev/null
+++ b/Easy/Type of Triangle II.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public String triangleType(int[] nums) {
+        Arrays.sort(nums);
+        if (nums[0] + nums[1] <= nums[2]) {
+            return "none";
+        }
+        if (nums[0] == nums[1] && nums[1] == nums[2]) {
+            return "equilateral";
+        }
+        if (nums[0] == nums[1] || nums[1] == nums[2] || nums[0] == nums[2]) {
+            return "isosceles";
+        }
+        return "scalene";
+    }
+}

From 0e0fd4fc584279fa718e5d41dcd50799c834c671 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Feb 2024 17:20:24 -0800
Subject: [PATCH 1929/2175] Update Minimum Window Substring.java

---
 Hard/Minimum Window Substring.java | 66 +++++++++++++++---------------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/Hard/Minimum Window Substring.java b/Hard/Minimum Window Substring.java
index 2e8bb271..40cfa2ce 100644
--- a/Hard/Minimum Window Substring.java	
+++ b/Hard/Minimum Window Substring.java	
@@ -1,38 +1,38 @@
 class Solution {
-  public String minWindow(String s, String t) {
-    Map<Character, Integer> map = new HashMap<>();
-    for (char c : t.toCharArray()) {
-      map.put(c, map.getOrDefault(c, 0) + 1);
-    }
-    int count = map.size();
-    int start = 0;
-    int end = 0;
-    int minWindowLength = Integer.MAX_VALUE;
-    int minWindowStart = 0;
-    int minWindowEnd = 0;
-    while (end < s.length()) {
-      char c = s.charAt(end++);
-      if (map.containsKey(c)) {
-        map.put(c, map.get(c) - 1);
-        if (map.get(c) == 0) {
-          count--;
-        }
-      }
-      while (count == 0 && start < end) {
-        if (end - start < minWindowLength) {
-          minWindowLength = end - start;
-          minWindowStart = start;
-          minWindowEnd = end;
+    public String minWindow(String s, String t) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : t.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
         }
-        char temp = s.charAt(start++);
-        if (map.containsKey(temp)) {
-          map.put(temp, map.get(temp) + 1);
-          if (map.get(temp) == 1) {
-            count++;
-          }
+        int targetSize = map.size();
+        int start = 0;
+        int minLength = Integer.MAX_VALUE;
+        int minStart = -1;
+        int minEnd = -1;
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            if (map.containsKey(s.charAt(i))) {
+                map.put(s.charAt(i), map.get(s.charAt(i)) - 1);
+                if (map.get(s.charAt(i)) == 0) {
+                    targetSize--;
+                }
+            }
+            while (start <= i && targetSize == 0) {
+                int currLength = i - start;
+                if (minLength > currLength) {
+                    minLength = currLength;
+                    minStart = start;
+                    minEnd = i + 1;
+                }   
+                if (map.containsKey(s.charAt(start))) {
+                    map.put(s.charAt(start), map.get(s.charAt(start)) + 1);
+                    if (map.get(s.charAt(start)) == 1) {
+                        targetSize++;
+                    }
+                }
+                start++;
+            }
         }
-      }
+        return minLength == Integer.MAX_VALUE ? "" : s.substring(minStart, minEnd);
     }
-    return s.substring(minWindowStart, minWindowEnd);
-  }
 }

From a34609dbc45bde03ae818da284ff60751f1c2955 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 4 Feb 2024 08:36:19 -0800
Subject: [PATCH 1930/2175] Create Ant on the Boundary.java

---
 Easy/Ant on the Boundary.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Ant on the Boundary.java

diff --git a/Easy/Ant on the Boundary.java b/Easy/Ant on the Boundary.java
new file mode 100644
index 00000000..25e95d0a
--- /dev/null
+++ b/Easy/Ant on the Boundary.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int returnToBoundaryCount(int[] nums) {
+        int currPosition = 0;
+        int count = 0;
+        for (int num : nums) {
+            currPosition += num;
+            if (currPosition == 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

From a17462d2ec5648f87f6aebba8e697440832586a4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 Feb 2024 09:36:17 -0800
Subject: [PATCH 1931/2175] Update and rename Paint Fence.java to Paint
 Fence.java

---
 Easy/Paint Fence.java   | 12 ------------
 Medium/Paint Fence.java | 20 ++++++++++++++++++++
 2 files changed, 20 insertions(+), 12 deletions(-)
 delete mode 100644 Easy/Paint Fence.java
 create mode 100644 Medium/Paint Fence.java

diff --git a/Easy/Paint Fence.java b/Easy/Paint Fence.java
deleted file mode 100644
index 72ea89e6..00000000
--- a/Easy/Paint Fence.java	
+++ /dev/null
@@ -1,12 +0,0 @@
-class Solution {
-  public int numWays(int n, int k) {
-    int[] ways = new int[Math.max(n + 1, 3)];
-    ways[0] = 0;
-    ways[1] = k;
-    ways[2] = k * k;
-    for (int i = 3; i <= n; i++) {
-      ways[i] = (ways[i - 1] * (k - 1)) + (ways[i - 2] * (k - 1));
-    }
-    return ways[n];
-  }
-}
diff --git a/Medium/Paint Fence.java b/Medium/Paint Fence.java
new file mode 100644
index 00000000..39c72ffa
--- /dev/null
+++ b/Medium/Paint Fence.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int numWays(int n, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        return numWays(n, k, map);
+    }
+
+    private int numWays(int n, int k, Map<Integer, Integer> map) {
+        if (n == 1) {
+            return k;
+        }
+        if (n == 2) {
+            return k * k;
+        }
+        if (map.containsKey(n)) {
+            return map.get(n);
+        }
+        map.put(n, (k - 1) * (numWays(n - 1, k, map) + numWays(n - 2, k, map)));
+        return map.get(n);
+    }
+}

From 17a14ddd732392cccb9b1cfe6fbd35b6f9e0e1c8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Feb 2024 08:35:13 -0800
Subject: [PATCH 1932/2175] Create Cherry Pickup II.java

---
 Hard/Cherry Pickup II.java | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Hard/Cherry Pickup II.java

diff --git a/Hard/Cherry Pickup II.java b/Hard/Cherry Pickup II.java
new file mode 100644
index 00000000..1786e8cc
--- /dev/null
+++ b/Hard/Cherry Pickup II.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public int cherryPickup(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        Integer[][][] cache = new Integer[m][n][n];
+        return recurse(0, 0, n - 1, grid, cache);
+    }
+
+    private int recurse(int row, int colOne, int colTwo, int[][] grid, Integer[][][] cache) {
+        if (colOne < 0 || colOne >= grid[0].length || colTwo < 0 || colTwo >= grid[0].length) {
+            return 0;
+        }
+        if (cache[row][colOne][colTwo] != null) {
+            return cache[row][colOne][colTwo];
+        }
+        int result = 0;
+        result += grid[row][colOne];
+        if (colOne != colTwo) {
+            result += grid[row][colTwo];
+        }
+        if (row != grid.length - 1) {
+            int max = 0;
+            for (int c1 = colOne - 1; c1 <= colOne + 1; c1++) {
+                for (int c2 = colTwo - 1; c2 <= colTwo + 1; c2++) {
+                    max = Math.max(max, recurse(row + 1, c1, c2, grid, cache));
+                } 
+            }
+            result += max;
+        }
+        return cache[row][colOne][colTwo] = result;
+    }
+}

From 35f002278987a3c1a67ef84799bfc07172c0f181 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Feb 2024 08:44:51 -0800
Subject: [PATCH 1933/2175] Create Modify the Matrix.java

---
 Easy/Modify the Matrix.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Easy/Modify the Matrix.java

diff --git a/Easy/Modify the Matrix.java b/Easy/Modify the Matrix.java
new file mode 100644
index 00000000..f238aa68
--- /dev/null
+++ b/Easy/Modify the Matrix.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int[][] modifiedMatrix(int[][] matrix) {
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+        for (int c = 0; c < cols; c++) {
+            int max = -1;
+            for (int r = 0; r < rows; r++) {
+                max = Math.max(max, matrix[r][c]);
+            }
+            for (int r = 0; r < rows; r++) {
+                matrix[r][c] = matrix[r][c] == -1 ? max : matrix[r][c];
+            }
+        }
+        return matrix;
+    }
+}

From 21490738b68c45bcdf1555a024afbbd73790d4f7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 12 Feb 2024 16:23:24 -0800
Subject: [PATCH 1934/2175] Update Find First Palindromic String in the
 Array.java

---
 .../Find First Palindromic String in the Array.java | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/Easy/Find First Palindromic String in the Array.java b/Easy/Find First Palindromic String in the Array.java
index ba990c09..e215ab8d 100644
--- a/Easy/Find First Palindromic String in the Array.java	
+++ b/Easy/Find First Palindromic String in the Array.java	
@@ -1,9 +1,8 @@
 class Solution {
-  public String firstPalindrome(String[] words) {
-    return Arrays.stream(words).filter(Solution::isPalindrome).findFirst().orElse("");
-  }
-  
-  public static boolean isPalindrome(String s) {
-    return new StringBuilder().append(s).reverse().toString().equals(s);
-  }
+    public String firstPalindrome(String[] words) {
+        return Arrays.stream(words)
+            .filter(word -> word.equals(new StringBuilder(word).reverse().toString()))
+            .findFirst()
+            .orElse("");
+    }
 }

From e9713200867ee54d79dcd980c35754a893f4bde7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 13 Feb 2024 18:44:00 -0800
Subject: [PATCH 1935/2175] Update Rearrange Array Elements by Sign.java

---
 Medium/Rearrange Array Elements by Sign.java | 33 +++++++++-----------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/Medium/Rearrange Array Elements by Sign.java b/Medium/Rearrange Array Elements by Sign.java
index d2eb68e7..83857f13 100644
--- a/Medium/Rearrange Array Elements by Sign.java	
+++ b/Medium/Rearrange Array Elements by Sign.java	
@@ -1,21 +1,18 @@
 class Solution {
-  public int[] rearrangeArray(int[] nums) {
-    List<Integer> positive = new ArrayList<>();
-    List<Integer> negative = new ArrayList<>();
-    for (int num : nums) {
-      if (num > 0) {
-        positive.add(num);
-      } else {
-        negative.add(num);
-      }
+    public int[] rearrangeArray(int[] nums) {
+        int n = nums.length;
+        int[] result = new int[n];
+        int posIndex = 0;
+        int negIndex = 1;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] > 0) {
+                result[posIndex] = nums[i];
+                posIndex += 2;
+            } else {
+                result[negIndex] = nums[i];
+                negIndex += 2;
+            }
+        }
+        return result;
     }
-    int positiveIdx = 0;
-    int negativeIdx = 0;
-    boolean positiveFlag = true;
-    for (int i = 0; i < nums.length; i++) {
-      nums[i] = positiveFlag ? positive.get(positiveIdx++) : negative.get(negativeIdx++);
-      positiveFlag = !positiveFlag;
-    }
-    return nums;
-  }
 }

From 44b4003e764421409f071f0f4ee2367cdf65af6f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 15 Feb 2024 07:51:41 -0800
Subject: [PATCH 1936/2175] Create Find Polygon With the Largest Perimeter.java

---
 .../Find Polygon With the Largest Perimeter.java  | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Find Polygon With the Largest Perimeter.java

diff --git a/Medium/Find Polygon With the Largest Perimeter.java b/Medium/Find Polygon With the Largest Perimeter.java
new file mode 100644
index 00000000..8b368cb2
--- /dev/null
+++ b/Medium/Find Polygon With the Largest Perimeter.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public long largestPerimeter(int[] nums) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        long prefixSum = 0;
+        long result = -1;
+        for (int i = 0; i < n; i++) {
+            if (i >= 2 && nums[i] < prefixSum) {
+                result = nums[i] + prefixSum;
+            }
+            prefixSum += nums[i];
+        }
+        return result;
+    }
+}

From 93ab03af6feba7c6fe6653a97c7224f71fcc1318 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 15 Feb 2024 08:18:50 -0800
Subject: [PATCH 1937/2175] Update Remove Interval.java

---
 Medium/Remove Interval.java | 47 ++++++++++++++++++++++++++-----------
 1 file changed, 33 insertions(+), 14 deletions(-)

diff --git a/Medium/Remove Interval.java b/Medium/Remove Interval.java
index 0405621d..e64370e0 100644
--- a/Medium/Remove Interval.java	
+++ b/Medium/Remove Interval.java	
@@ -1,18 +1,37 @@
 class Solution {
-  public List<List<Integer>> removeInterval(int[][] intervals, int[] toBeRemoved) {
-    List<List<Integer>> result = new ArrayList<>();
-    for (int[] interval : intervals) {
-      if (interval[0] > toBeRemoved[1] || interval[1] < toBeRemoved[0]) {
-        result.add(Arrays.asList(interval[0], interval[1]));
-      } else {
-        if (interval[0] < toBeRemoved[0]) {
-          result.add(Arrays.asList(interval[0], toBeRemoved[0]));
+    public List<List<Integer>> removeInterval(int[][] intervals, int[] toBeRemoved) {
+        List<List<Integer>> result = new ArrayList<>();
+        int n = intervals.length;
+        int removeStart = toBeRemoved[0];
+        int removeEnd = toBeRemoved[1];
+        for (int i = 0; i < n; i++) {
+            int currStart = intervals[i][0];
+            int currEnd = intervals[i][1];
+            // complete overlap hence skipping complete interval
+            if (currStart >= removeStart && currEnd <= removeEnd) {
+                continue;
+            }
+            // no overlap hence adding complete interval
+            if ((currStart <= removeStart && currEnd <= removeStart) || (currStart >= removeEnd && currEnd >= removeEnd)) {
+                result.add(List.of(currStart, currEnd));
+                continue;
+            } 
+            // partial overlaps
+            if (currStart <= removeStart) {
+                int newStart = Math.min(currStart, removeStart);
+                int newEnd = Math.max(currStart, removeStart);
+                if (newStart != newEnd) {
+                    result.add(List.of(newStart, newEnd));
+                }
+            }
+            if (currEnd >= removeEnd) {
+                int newStart = Math.min(currEnd, removeEnd);
+                int newEnd = Math.max(currEnd, removeEnd);
+                if (newStart != newEnd) {
+                    result.add(List.of(newStart, newEnd));
+                }
+            }
         }
-        if (interval[1] > toBeRemoved[1]) {
-          result.add(Arrays.asList(toBeRemoved[1], interval[1]));
-        }
-      }
+        return result;
     }
-    return result;
-  } 
 }

From 27c4b6e881ec76385a72b729b47d0859be16f69b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 16 Feb 2024 07:40:47 -0800
Subject: [PATCH 1938/2175] Update Least Number of Unique Integers after K
 Removals.java

---
 ...r of Unique Integers after K Removals.java | 41 ++++++++-----------
 1 file changed, 16 insertions(+), 25 deletions(-)

diff --git a/Medium/Least Number of Unique Integers after K Removals.java b/Medium/Least Number of Unique Integers after K Removals.java
index 30b56fac..c6755d8e 100644
--- a/Medium/Least Number of Unique Integers after K Removals.java	
+++ b/Medium/Least Number of Unique Integers after K Removals.java	
@@ -1,28 +1,19 @@
 class Solution {
-  public int findLeastNumOfUniqueInts(int[] arr, int k) {
-    Map<Integer, Integer> map = new HashMap<>();
-    List<Integer> list = new ArrayList<>();
-    for (int num : arr) {
-      if (!map.containsKey(num)) {
-        list.add(num);
-      }
-      map.put(num, map.getOrDefault(num, 0) + 1);
+    public int findLeastNumOfUniqueInts(int[] arr, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : arr) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> map.get(a).compareTo(map.get(b)));
+        pq.addAll(map.keySet());
+        while (k > 0 && !pq.isEmpty()) {
+            int count = map.get(pq.peek());
+            if (count > k) {
+                break;
+            }
+            k -= count;
+            pq.poll();
+        }
+        return pq.size();
     }
-    Collections.sort(list, new Comparator<Integer>(){
-      public int compare(Integer o1, Integer o2) {
-        return map.get(o1) - map.get(o2);
-      }
-    });
-    for (Integer num : list) {
-      int count = map.get(num);
-      k -= count;
-      if (k >= 0) {
-        map.remove(num);
-      }
-      else {
-       break; 
-      }
-    }
-    return map.size();
-  }
 }

From d39e2e130ed7d4bc456ccfce11ba7a41a5f410be Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 17 Feb 2024 08:33:11 -0800
Subject: [PATCH 1939/2175] Update Furthest Building You Can Reach.java

---
 Medium/Furthest Building You Can Reach.java | 30 +++++++++++----------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/Medium/Furthest Building You Can Reach.java b/Medium/Furthest Building You Can Reach.java
index 2c901072..1e110678 100644
--- a/Medium/Furthest Building You Can Reach.java	
+++ b/Medium/Furthest Building You Can Reach.java	
@@ -1,18 +1,20 @@
 class Solution {
-  public int furthestBuilding(int[] heights, int bricks, int ladders) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>();
-    for (int i = 1; i < heights.length; i++) {
-      int diff = heights[i] - heights[i - 1];
-      if (diff > 0) {
-        pq.add(diff);
-        if (pq.size() > ladders) {
-          bricks -= pq.poll();
+    public int furthestBuilding(int[] heights, int bricks, int ladders) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        for (int i = 1; i < heights.length; i++) {
+            int diff = heights[i] - heights[i - 1];
+            if (diff > 0) {
+                pq.add(diff);
+                bricks -= diff;
+                if (bricks < 0) {
+                    if (ladders == 0) {
+                        return i - 1;
+                    }
+                    ladders--;
+                    bricks += pq.poll();
+                }
+            }
         }
-        if (bricks < 0) {
-          return i - 1;
-        }
-      }
+        return heights.length - 1;
     }
-    return heights.length - 1;
-  }
 }

From 6a44f83154dbdb7757dad9f585403e8002cdefd6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 17 Feb 2024 09:05:35 -0800
Subject: [PATCH 1940/2175] Create Maximum Number of Operations With the Same
 Score I.java

---
 ...umber of Operations With the Same Score I.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Maximum Number of Operations With the Same Score I.java

diff --git a/Easy/Maximum Number of Operations With the Same Score I.java b/Easy/Maximum Number of Operations With the Same Score I.java
new file mode 100644
index 00000000..22f6648d
--- /dev/null
+++ b/Easy/Maximum Number of Operations With the Same Score I.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int maxOperations(int[] nums) {
+        int score = -1;
+        int operations = 0;
+        for (int i = 0; i <= nums.length - 2; i += 2) {
+            int currScore = nums[i] + nums[i + 1];
+            if (score != -1 && score != currScore) {
+                break;
+            } 
+            score = currScore;
+            operations++;
+        }
+        return operations;
+    }
+}

From e84e665fe0f5a8cf8ff7462b24f4146839f6d9a4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 17 Feb 2024 14:13:07 -0800
Subject: [PATCH 1941/2175] Create Apply Operations to Make String Empty.java

---
 .../Apply Operations to Make String Empty.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Apply Operations to Make String Empty.java

diff --git a/Medium/Apply Operations to Make String Empty.java b/Medium/Apply Operations to Make String Empty.java
new file mode 100644
index 00000000..c378a060
--- /dev/null
+++ b/Medium/Apply Operations to Make String Empty.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public String lastNonEmptyString(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int maxFrequency = 0;
+        for (int i = 0; i < s.length(); i++) {
+            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
+            maxFrequency = Math.max(maxFrequency, map.get(s.charAt(i)));
+        }
+        StringBuilder result = new StringBuilder();
+        for (int i = s.length() - 1; i >= 0; i--) {
+            if (map.get(s.charAt(i)) == maxFrequency) {
+                result.append(s.charAt(i));
+                map.put(s.charAt(i), map.get(s.charAt(i)) - 1);
+            }
+        }
+        return result.reverse().toString();
+    }
+}

From fb2b1babb63940655fd664a7b394652c44d0b6e9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 18 Feb 2024 13:22:50 -0800
Subject: [PATCH 1942/2175] Create Meeting Rooms III.java

---
 Hard/Meeting Rooms III.java | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Hard/Meeting Rooms III.java

diff --git a/Hard/Meeting Rooms III.java b/Hard/Meeting Rooms III.java
new file mode 100644
index 00000000..48167f8c
--- /dev/null
+++ b/Hard/Meeting Rooms III.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int mostBooked(int n, int[][] meetings) {
+        Arrays.sort(meetings, Comparator.comparingInt(o -> o[0]));
+        PriorityQueue<int[]> ongoingMeetings = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+        int[] frequency = new int[n];
+        PriorityQueue<long[]> pq = new PriorityQueue<>((o1, o2) -> o1[0] == o2[0] ? (int) (o1[1] - o2[1]) : (int) (o1[0] - o2[0]));
+        for (int i = 0; i < n; i++) {
+            pq.add(new long[]{0, i});
+        }
+        for (int[] meeting : meetings) {
+            int startTime = meeting[0];
+            while (pq.peek()[0] < startTime) {
+                pq.add(new long[]{startTime, pq.poll()[1]});
+            }
+            long[] finishedMeeting = pq.poll();
+            int room = (int) finishedMeeting[1];
+            long endTime = finishedMeeting[0] + (meeting[1] - meeting[0]);
+            frequency[room]++;
+            pq.add(new long[]{endTime, room});
+        }
+        int maxCount = 0;
+        int roomWithMaxCount = 0;
+        for (int i = 0; i < n; i++) {
+            if (frequency[i] > maxCount) {
+                maxCount = frequency[i];
+                roomWithMaxCount = i;
+            }
+        }
+        return roomWithMaxCount;
+    }
+}

From cb1e04e3a9d3add7f138f9cbf7668db4cb86714c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 19 Feb 2024 09:28:35 -0800
Subject: [PATCH 1943/2175] Create Count Prefix and Suffix Pairs I.java

---
 Easy/Count Prefix and Suffix Pairs I.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Count Prefix and Suffix Pairs I.java

diff --git a/Easy/Count Prefix and Suffix Pairs I.java b/Easy/Count Prefix and Suffix Pairs I.java
new file mode 100644
index 00000000..919d41d1
--- /dev/null
+++ b/Easy/Count Prefix and Suffix Pairs I.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int countPrefixSuffixPairs(String[] words) {
+        int count = 0;
+        for (int i = 0; i < words.length; i++) {
+            String target = words[i];
+            for (int j = i + 1; j < words.length; j++) {
+                if (words[j].startsWith(target) && words[j].endsWith(target)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+}

From 97306e9c4c504de09d9e22dec3f9b9a6ec8e40f1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Feb 2024 07:25:19 -0800
Subject: [PATCH 1944/2175] Create Find the Length of the Longest Common
 Prefix.java

---
 ...e Length of the Longest Common Prefix.java | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 Medium/Find the Length of the Longest Common Prefix.java

diff --git a/Medium/Find the Length of the Longest Common Prefix.java b/Medium/Find the Length of the Longest Common Prefix.java
new file mode 100644
index 00000000..a626cd3a
--- /dev/null
+++ b/Medium/Find the Length of the Longest Common Prefix.java	
@@ -0,0 +1,52 @@
+class Solution {
+    public int longestCommonPrefix(int[] arr1, int[] arr2) {
+        TrieNodeManager nodeManager = new TrieNodeManager();
+        for (int num : arr1) {
+            nodeManager.index(String.valueOf(num));
+        }
+        int maxLength = 0;
+        for (int num : arr2) {
+            int length = nodeManager.find(String.valueOf(num));
+            maxLength = Math.max(maxLength, length);
+        }
+        return maxLength;
+    }
+    
+    private static class TrieNodeManager {
+        
+        private Node root;
+        
+        public TrieNodeManager() {
+            this.root = new Node();
+        }
+        
+        public void index(String s) {
+            Node curr = root;
+            for (char c : s.toCharArray()) {
+                if (!curr.children.containsKey(c)) {
+                    curr.children.put(c, new Node());
+                }
+                curr = curr.children.get(c);
+            }
+        }
+        
+        public int find(String s) {
+            Node curr = root;
+            for (int i = 0; i < s.length(); i++) {
+                if (!curr.children.containsKey(s.charAt(i))) {
+                    return i;
+                }
+                curr = curr.children.get(s.charAt(i));
+            }
+            return s.length();
+        }
+        
+        class Node {
+            Map<Character, Node> children;
+            
+            public Node() {
+                this.children = new HashMap<>();
+            }
+        }
+    }
+}

From 4422419e6f9e31a87188c8ec4fedc064a1956d6f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 24 Feb 2024 14:01:33 -0800
Subject: [PATCH 1945/2175] Create Find All People With Secret.java

---
 Hard/Find All People With Secret.java | 39 +++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Hard/Find All People With Secret.java

diff --git a/Hard/Find All People With Secret.java b/Hard/Find All People With Secret.java
new file mode 100644
index 00000000..b18f289a
--- /dev/null
+++ b/Hard/Find All People With Secret.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public List<Integer> findAllPeople(int n, int[][] meetings, int firstPerson) {
+        Map<Integer, List<int[]>> graph = new HashMap<>();
+        for (int[] meeting : meetings) {
+            int x = meeting[0];
+            int y = meeting[1];
+            int time = meeting[2];
+            graph.computeIfAbsent(x, k -> new ArrayList<>()).add(new int[]{time, y});
+            graph.computeIfAbsent(y, k -> new ArrayList<>()).add(new int[]{time, x});
+        }
+        int[] earliestTime = new int[n];
+        Arrays.fill(earliestTime, Integer.MAX_VALUE);
+        earliestTime[0] = 0;
+        earliestTime[firstPerson] = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0}); 
+        queue.add(new int[]{firstPerson, 0}); 
+        while (!queue.isEmpty()) {
+            int[] removed = queue.poll();
+            int person = removed[0];
+            int time = removed[1];
+            for (int[] conn : graph.getOrDefault(person, new ArrayList<>())) {
+                int t = conn[0];
+                int p = conn[1];
+                if (t >= time && earliestTime[p] > t) {
+                    earliestTime[p] = t;
+                    queue.add(new int[]{p, t});
+                }
+            }
+        }
+        List<Integer> result = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (earliestTime[i] != Integer.MAX_VALUE) {
+                result.add(i);
+            }
+        }
+        return result;
+    }
+}

From 4aef2f9bf3a0d8ad311bc2aba12aaa760fa81944 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Feb 2024 13:15:29 -0800
Subject: [PATCH 1946/2175] Create Greatest Common Divisor Traversal.java

---
 Hard/Greatest Common Divisor Traversal.java | 80 +++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 Hard/Greatest Common Divisor Traversal.java

diff --git a/Hard/Greatest Common Divisor Traversal.java b/Hard/Greatest Common Divisor Traversal.java
new file mode 100644
index 00000000..81ab07de
--- /dev/null
+++ b/Hard/Greatest Common Divisor Traversal.java	
@@ -0,0 +1,80 @@
+class Solution {
+
+    private static final int MAX = 100_000;
+
+    public boolean canTraverseAllPairs(int[] nums) {
+        int n = nums.length;
+        if (n == 1) {
+            return true;
+        }
+        boolean[] exists = new boolean[MAX + 1];
+        for (int num : nums) {
+            exists[num] = true;
+        }
+        if (exists[1]) {
+            return false;
+        }
+        int[] sieve = new int[MAX + 1];
+        for (int i = 2; i <= MAX; i++) {
+            if (sieve[i] == 0) {
+                for (int j = i; j <= MAX; j += i) {
+                    sieve[j] = i;
+                }
+            }
+        }
+        Union union = new Union(2 * MAX + 1);
+        for (int num : nums) {
+            int curr = num;
+            while (curr > 1) {
+                int prime = sieve[curr];
+                int root = prime + MAX;
+                if (union.find(root) != union.find(num)) {
+                    union.merge(root, num);
+                }
+                while (curr % prime == 0) {
+                    curr /= prime;
+                }
+            }
+        }
+        int count = 0;
+        for (int i = 2; i <= MAX; i++) {
+            if (exists[i] && union.find(i) == i) {
+                count++;
+            }
+        }
+        return count == 1;
+    }
+
+    private class Union {
+        private final int[] union;
+        private final int[] size;
+
+        public Union(int n) {
+            this.union = new int[n + 1];
+            this.size = new int[n + 1];
+            for (int i = 0; i <= n; i++) {
+                union[i] = i;
+                size[i] = 1;
+            }
+        }
+
+        public int find(int num) {
+            return union[num] == num ? num : (union[num] = find(union[num]));
+        }
+
+        public void merge(int x, int y) {
+            int findX = find(x);
+            int findY = find(y);
+            if (findX == findY) {
+                return;
+            }
+            if (size[findX] > size[findY]) {
+                int temp = findX;
+                findX = findY;
+                findY = temp;
+            }
+            union[findX] = findY;
+            size[findY] += size[findX];
+        }
+    }
+}

From 252eda75201e61ac7b6ecb3173725ceee8cb22f9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Feb 2024 15:41:18 -0800
Subject: [PATCH 1947/2175] Create Split the Array.java

---
 Easy/Split the Array.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Split the Array.java

diff --git a/Easy/Split the Array.java b/Easy/Split the Array.java
new file mode 100644
index 00000000..607a2de0
--- /dev/null
+++ b/Easy/Split the Array.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean isPossibleToSplit(int[] nums) {
+        return Arrays.stream(nums)
+                .boxed()
+                .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()))
+                .values()
+                .stream()
+                .allMatch(v -> v <= 2);
+    }
+}

From 1743d9da0de4b2a368612ff63d99ec878da0447d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Feb 2024 16:55:42 -0800
Subject: [PATCH 1948/2175] Update Tree Diameter.java

---
 Medium/Tree Diameter.java | 63 ++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 30 deletions(-)

diff --git a/Medium/Tree Diameter.java b/Medium/Tree Diameter.java
index 28dca810..87d5eab9 100644
--- a/Medium/Tree Diameter.java	
+++ b/Medium/Tree Diameter.java	
@@ -1,36 +1,39 @@
 class Solution {
-  public int treeDiameter(int[][] edges) {
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    for (int[] edge : edges) {
-      graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
-      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    public int treeDiameter(int[][] edges) {
+        int n = edges.length;
+        List<Set<Integer>> graph = new ArrayList<>();
+        boolean[] visited = new boolean[n + 1];
+        for (int i = 0; i < n + 1; i++) {
+            graph.add(new HashSet<>());
+        }
+        for (int[] edge : edges) {
+            int nodeOne = edge[0];
+            int nodeTwo = edge[1];
+            graph.get(nodeOne).add(nodeTwo);
+            graph.get(nodeTwo).add(nodeOne);
+        }
+        int[] diameter = {0};
+        dfs(0, visited, graph, diameter);
+        return diameter[0];
     }
-    int farthestNode = bfsHelper(graph, 0)[0];
-    return bfsHelper(graph, farthestNode)[1];
-  }
 
-  private int[] bfsHelper(Map<Integer, List<Integer>> graph, int node) {
-    int farthestNode = 0;
-    int steps = 0;
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(node);
-    Set<Integer> visited = new HashSet<>();
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size--  > 0) {
-        int removedNode = queue.remove();
-        visited.add(removedNode);
-        farthestNode = removedNode;
-        for (Integer peer : graph.getOrDefault(removedNode, new ArrayList<>())) {
-          if (!visited.contains(peer)) {
-            queue.add(peer);
-          }
+    private int dfs(int node, boolean[] visited, List<Set<Integer>> graph, int[] diameter) {
+        int highestDistance = 0;
+        int secondHighestDistance = 0;
+        visited[node] = true;
+        for (Integer conn : graph.get(node)) {
+            int distance = 0;
+            if (!visited[conn]) {
+                distance = 1 + dfs(conn, visited, graph, diameter);
+            }
+            if (distance > highestDistance) {
+                secondHighestDistance = highestDistance;
+                highestDistance = distance;
+            } else if (distance > secondHighestDistance) {
+                secondHighestDistance = distance;
+            }
         }
-      }
-      if (!queue.isEmpty()) {
-        steps++;
-      }
+        diameter[0] = Math.max(diameter[0], highestDistance + secondHighestDistance);
+        return highestDistance;
     }
-    return new int[]{farthestNode, steps};
-  }
 }

From f57b3dbaccdc73c0b0f467c89bcd6066ae298008 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 28 Feb 2024 19:09:51 -0800
Subject: [PATCH 1949/2175] Update Even Odd Tree.java

---
 Medium/Even Odd Tree.java | 55 ++++++++++++++++++---------------------
 1 file changed, 25 insertions(+), 30 deletions(-)

diff --git a/Medium/Even Odd Tree.java b/Medium/Even Odd Tree.java
index 0d3a4886..574ddf6b 100644
--- a/Medium/Even Odd Tree.java	
+++ b/Medium/Even Odd Tree.java	
@@ -14,36 +14,31 @@
  * }
  */
 class Solution {
-  public boolean isEvenOddTree(TreeNode root) {
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    int remainderExpected = 1;
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      Integer prev = null;
-      while (size-- > 0) {
-        TreeNode removed = queue.remove();
-        if (removed.val % 2 != remainderExpected) {
-          return false;
+    public boolean isEvenOddTree(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        boolean even = true;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            int prev = even ? Integer.MIN_VALUE : Integer.MAX_VALUE;
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                if ((even && removed.val % 2 == 0) || (!even && removed.val % 2 != 0)) {
+                    return false;
+                }
+                if ((even && removed.val <= prev) || (!even && removed.val >= prev)) {
+                    return false;
+                }
+                prev = removed.val;
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            even = !even;
         }
-        if (prev != null) {
-          if (remainderExpected == 1 && removed.val <= prev) {
-            return false;
-          } 
-          if (remainderExpected == 0 && removed.val >= prev) {
-            return false;
-          } 
-        }
-        prev = removed.val;
-        if (removed.left != null) {
-          queue.add(removed.left);
-        }
-        if (removed.right != null) {
-          queue.add(removed.right);
-        }
-      }
-      remainderExpected = remainderExpected == 1 ? 0 : 1;
+        return true;
     }
-    return true;
-  }
 }

From 1f6ead115dcbd62dab8dd3dc29110146a7398266 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 29 Feb 2024 18:06:03 -0800
Subject: [PATCH 1950/2175] Create Winner of the Linked List Game.java

---
 Easy/Winner of the Linked List Game.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Easy/Winner of the Linked List Game.java

diff --git a/Easy/Winner of the Linked List Game.java b/Easy/Winner of the Linked List Game.java
new file mode 100644
index 00000000..198fdd75
--- /dev/null
+++ b/Easy/Winner of the Linked List Game.java	
@@ -0,0 +1,23 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public String gameResult(ListNode head) {
+        ListNode curr = head;
+        int count = 0;
+        while (curr != null) {
+            int even = curr.val;
+            int odd = curr.next.val;
+            count += even == odd ? 0 : (even > odd ? 1 : -1);
+            curr = curr.next.next;
+        }
+        return count == 0 ? "Tie" : (count > 0 ? "Even" : "Odd");
+    }
+}

From e3de53f51a0f667f77047d6d2f4a74528aac578d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Mar 2024 10:15:32 -0800
Subject: [PATCH 1951/2175] Update Squares of a Sorted Array.java

---
 Easy/Squares of a Sorted Array.java | 36 +++++++++++------------------
 1 file changed, 14 insertions(+), 22 deletions(-)

diff --git a/Easy/Squares of a Sorted Array.java b/Easy/Squares of a Sorted Array.java
index 046fcf9c..08f5faa6 100644
--- a/Easy/Squares of a Sorted Array.java	
+++ b/Easy/Squares of a Sorted Array.java	
@@ -1,26 +1,18 @@
 class Solution {
-  public int[] sortedSquares(int[] nums) {
-    int negativeIdx = 0;
-    int positiveIdx = nums.length - 1;
-    int[] result = new int[nums.length];
-    int resultIdx = nums.length - 1;
-    while(resultIdx >= 0) {
-      if (nums[negativeIdx] < 0 && nums[positiveIdx] >= 0) {
-        if (Math.abs(nums[negativeIdx]) > nums[positiveIdx]) {
-          result[resultIdx--] = nums[negativeIdx] * nums[negativeIdx];
-          negativeIdx++;
-        } else {
-          result[resultIdx--] = nums[positiveIdx] * nums[positiveIdx];
-          positiveIdx--;
+    public int[] sortedSquares(int[] nums) {
+        int n = nums.length;
+        int start = 0;
+        int end = n - 1;
+        int[] result = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            if (Math.abs(nums[start]) >= Math.abs(nums[end])) {
+                result[i] = nums[start] * nums[start];
+                start++;
+            } else {
+                result[i] = nums[end] * nums[end];
+                end--;
+            }
         }
-      } else if (nums[negativeIdx] < 0 && nums[positiveIdx] < 0) {
-        result[resultIdx--] = nums[negativeIdx] * nums[negativeIdx];
-        negativeIdx++;
-      } else {
-        result[resultIdx--] = nums[positiveIdx] * nums[positiveIdx];
-        positiveIdx--;  
-      }
+        return result;
     }
-    return result;
-  }
 }

From 92e8246b5ef50a7836df342cfc4501945a34e75a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 2 Mar 2024 13:59:35 -0800
Subject: [PATCH 1952/2175] Create Minimum Operations to Exceed Threshold Value
 I.java

---
 ...um Operations to Exceed Threshold Value I.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Minimum Operations to Exceed Threshold Value I.java

diff --git a/Easy/Minimum Operations to Exceed Threshold Value I.java b/Easy/Minimum Operations to Exceed Threshold Value I.java
new file mode 100644
index 00000000..6f792f07
--- /dev/null
+++ b/Easy/Minimum Operations to Exceed Threshold Value I.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int minOperations(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        pq.addAll(map.keySet());
+        int count = 0;
+        while (!pq.isEmpty() && pq.peek() < k) {
+            count += map.get(pq.poll());
+        }
+        return count;
+    }
+}

From db0976a8fdac0400635473c7baf879afe4d1bfcc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Mar 2024 10:27:35 -0800
Subject: [PATCH 1953/2175] Create Distribute Elements Into Two Arrays I.java

---
 ...Distribute Elements Into Two Arrays I.java | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Easy/Distribute Elements Into Two Arrays I.java

diff --git a/Easy/Distribute Elements Into Two Arrays I.java b/Easy/Distribute Elements Into Two Arrays I.java
new file mode 100644
index 00000000..9b4bd7d1
--- /dev/null
+++ b/Easy/Distribute Elements Into Two Arrays I.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int[] resultArray(int[] nums) {
+        int start = 0;
+        int end = nums.length - 1;
+        int[] result = new int[nums.length];
+        result[start++] = nums[0];
+        result[end--] = nums[1];
+        for (int i = 2; i < nums.length; i++) {
+            if (result[start - 1] > result[end + 1]) {
+                result[start++] = nums[i];
+            } else {
+                result[end--] = nums[i];
+            }
+        }
+        int left = end + 1;
+        int right = nums.length - 1;
+        while (left < right) {
+            int temp = result[left];
+            result[left] = result[right];
+            result[right] = temp;
+            left++;
+            right--;
+        }
+        return result;
+    }
+}

From 72203227b5ac66f2bf797225432a1cff1f3e35c4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 3 Mar 2024 16:54:35 -0800
Subject: [PATCH 1954/2175] Update Bag of Tokens.java

---
 Medium/Bag of Tokens.java | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/Medium/Bag of Tokens.java b/Medium/Bag of Tokens.java
index d86085c3..1a409e0c 100644
--- a/Medium/Bag of Tokens.java	
+++ b/Medium/Bag of Tokens.java	
@@ -1,23 +1,23 @@
 class Solution {
-  public int bagOfTokensScore(int[] tokens, int power) {
-    int score = 0;
-    Arrays.sort(tokens);
-    int leftIdx = 0;
-    int rightIdx = tokens.length - 1;
-    int currScore = 0;
-    while (leftIdx <= rightIdx) {
-      if (power >= tokens[leftIdx]) {
-        currScore++;
-        power -= tokens[leftIdx++];
-      } else {
-        if (currScore == 0) {
-          break;
+    public int bagOfTokensScore(int[] tokens, int power) {
+        int score = 0;
+        int currScore = 0;
+        Arrays.sort(tokens);
+        int left = 0;
+        int right = tokens.length - 1;
+        while (left <= right) {
+            if (power >= tokens[left]) {
+                currScore++;
+                power -= tokens[left++];
+            } else {
+                if (currScore == 0) {
+                    break;
+                }
+                currScore--;
+                power += tokens[right--];
+            }
+            score = Math.max(score, currScore);
         }
-        currScore--;
-        power += tokens[rightIdx--];
-      }
-      score = Math.max(score, currScore);
+        return score;
     }
-    return score;
-  }
 }

From 2c002d2b2318319224e92cad2f06ea1eea6dc2e9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Mar 2024 18:27:00 -0800
Subject: [PATCH 1955/2175] Create Minimum Length of String After Deleting
 Similar Ends.java

---
 ...h of String After Deleting Similar Ends.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Minimum Length of String After Deleting Similar Ends.java

diff --git a/Medium/Minimum Length of String After Deleting Similar Ends.java b/Medium/Minimum Length of String After Deleting Similar Ends.java
new file mode 100644
index 00000000..bc1c6c89
--- /dev/null
+++ b/Medium/Minimum Length of String After Deleting Similar Ends.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int minimumLength(String s) {
+        int start = 0;
+        int end = s.length() - 1;
+        while (start < end && s.charAt(start) == s.charAt(end)) {
+            char startChar = s.charAt(start);
+            char endChar = s.charAt(end);
+            while (start <= end && s.charAt(start) == startChar) {
+                start++;
+            }
+            while (end > start && s.charAt(end) == endChar) {
+                end--;
+            }
+        }
+        return end - start + 1;
+    }
+}

From 8c7400fb11c6eb1b5964d89374021a6292f0c0aa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 8 Mar 2024 06:34:57 -0800
Subject: [PATCH 1956/2175] Create Linked List Frequency.java

---
 Medium/Linked List Frequency.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Linked List Frequency.java

diff --git a/Medium/Linked List Frequency.java b/Medium/Linked List Frequency.java
new file mode 100644
index 00000000..1c5a1739
--- /dev/null
+++ b/Medium/Linked List Frequency.java	
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode frequenciesOfElements(ListNode head) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (ListNode curr = head; curr != null; curr = curr.next) {
+            map.put(curr.val, map.getOrDefault(curr.val, 0) + 1);
+        }
+        ListNode dummy = new ListNode(-1);
+        ListNode curr = dummy;
+        for (Integer key : map.keySet()) {
+            curr.next = new ListNode(map.get(key));
+            curr = curr.next;
+        }
+        return dummy.next;
+    }
+}

From 4ecc1187000ae9cd7d8eb20cd84265081c11ba5c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 9 Mar 2024 16:21:59 -0800
Subject: [PATCH 1957/2175] Update Intersection of Two Arrays.java

---
 Easy/Intersection of Two Arrays.java | 27 +++++----------------------
 1 file changed, 5 insertions(+), 22 deletions(-)

diff --git a/Easy/Intersection of Two Arrays.java b/Easy/Intersection of Two Arrays.java
index d05f4468..24a47d60 100644
--- a/Easy/Intersection of Two Arrays.java	
+++ b/Easy/Intersection of Two Arrays.java	
@@ -1,25 +1,8 @@
 class Solution {
-  public int[] intersection(int[] nums1, int[] nums2) {
-    boolean[][] found = new boolean[1001][2];
-    for (int num : nums1) {
-      found[num][0] = true;
+    public int[] intersection(int[] nums1, int[] nums2) {
+        Set<Integer> set1 = Arrays.stream(nums1).boxed().collect(Collectors.toSet());
+        Set<Integer> set2 = Arrays.stream(nums2).boxed().collect(Collectors.toSet());
+        set1.retainAll(set2);
+        return set1.stream().mapToInt(Integer::intValue).toArray();
     }
-    int count = 0;
-    for (int num : nums2) {
-      if (!found[num][1]) {
-        if (found[num][0]) {
-          count++;
-        }
-      }
-      found[num][1] = true;
-    }
-    int[] result = new int[count];
-    int idx = 0;
-    for (int i = 1; i <= 1000; i++) {
-      if (found[i][0] && found[i][1]) {
-        result[idx++] = i;
-      }
-    }
-    return result;
-  }
 }

From 6a885d7bc246222d2f47f5e1fd45afd740c6daf7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 10 Mar 2024 16:08:15 -0700
Subject: [PATCH 1958/2175] Create Apple Redistribution into Boxes.java

---
 Easy/Apple Redistribution into Boxes.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Apple Redistribution into Boxes.java

diff --git a/Easy/Apple Redistribution into Boxes.java b/Easy/Apple Redistribution into Boxes.java
new file mode 100644
index 00000000..d84bd8a8
--- /dev/null
+++ b/Easy/Apple Redistribution into Boxes.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int minimumBoxes(int[] apple, int[] capacity) {
+        int totalApples = 0;
+        for (int count : apple) {
+            totalApples  += count;
+        }
+        Arrays.sort(capacity);
+        int idx = capacity.length - 1;
+        int currCapacity = capacity[idx--];
+        while (totalApples > 0) {
+            int applesDeleted = Math.min(currCapacity, totalApples);
+            totalApples -= applesDeleted;
+            currCapacity -= applesDeleted;
+            if (currCapacity == 0 && totalApples > 0) {
+                currCapacity = capacity[idx--];
+            }
+        }
+        return capacity.length - idx - 1;
+    }
+}

From c0bd347683b4a68f38987495e8f4deca4efe2ec6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 11 Mar 2024 17:46:11 -0700
Subject: [PATCH 1959/2175] Update Remove Zero Sum Consecutive Nodes from
 Linked List.java

---
 ...um Consecutive Nodes from Linked List.java | 39 +++++++++----------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java b/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java
index 9807ca95..6f55accd 100644
--- a/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java	
+++ b/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java	
@@ -9,25 +9,24 @@
  * }
  */
 class Solution {
-  public ListNode removeZeroSumSublists(ListNode head) {
-    ListNode dummy = new ListNode(0);
-    ListNode curr = head;
-    dummy.next = head;
-    Map<Integer, ListNode> map = new HashMap<>();
-    int prefixSum = 0;
-    map.put(0, dummy);
-    while (curr != null) {
-      prefixSum += curr.val;
-      map.put(prefixSum, curr);
-      curr = curr.next;
+    public ListNode removeZeroSumSublists(ListNode head) {
+        ListNode dummy = new ListNode(0, head);
+        ListNode curr = dummy;
+        int prefixSum = 0;
+        Map<Integer, ListNode> map = new HashMap<>();
+        map.put(0, curr);
+        while (curr != null) {
+            prefixSum += curr.val;
+            map.put(prefixSum, curr);
+            curr = curr.next;
+        }
+        prefixSum = 0;
+        curr = dummy;
+        while (curr != null) {
+            prefixSum += curr.val;
+            curr.next = map.get(prefixSum).next;
+            curr = curr.next;
+        }
+        return dummy.next;
     }
-    prefixSum = 0;
-    curr = dummy;
-    while (curr != null) {
-      prefixSum += curr.val;
-      curr.next = map.get(prefixSum).next;
-      curr = curr.next;
-    }
-    return dummy.next;
-  }
 }

From c6160261c59698337b83083c2d6789a4527f90c4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Mar 2024 09:08:21 -0700
Subject: [PATCH 1960/2175] Create Find the Sum of Encrypted Integers.java

---
 Easy/Find the Sum of Encrypted Integers.java | 21 ++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Find the Sum of Encrypted Integers.java

diff --git a/Easy/Find the Sum of Encrypted Integers.java b/Easy/Find the Sum of Encrypted Integers.java
new file mode 100644
index 00000000..6cee31bc
--- /dev/null
+++ b/Easy/Find the Sum of Encrypted Integers.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int sumOfEncryptedInt(int[] nums) {
+        int sum = 0;
+        for (int num : nums) {
+            sum += getEncryptedSum(num);
+        }
+        return sum;
+    }
+    
+    private static int getEncryptedSum(int num) {
+        int count = 0;
+        int max = 0;
+        while (num > 0) {
+            int digit = num % 10;
+            num /= 10;
+            count++;
+            max = Math.max(digit, max);
+        }
+        return Integer.parseInt(String.join("", Collections.nCopies(count, String.valueOf(max))));
+    }
+}

From bc153969bf4bd1e700cbf3878130aeae1790322b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Mar 2024 09:18:11 -0700
Subject: [PATCH 1961/2175] Update Insert Interval.java

---
 Medium/Insert Interval.java | 45 +++++++++++++------------------------
 1 file changed, 16 insertions(+), 29 deletions(-)

diff --git a/Medium/Insert Interval.java b/Medium/Insert Interval.java
index a263b710..a90a6884 100644
--- a/Medium/Insert Interval.java	
+++ b/Medium/Insert Interval.java	
@@ -1,32 +1,19 @@
 class Solution {
-  public int[][] insert(int[][] intervals, int[] newInterval) {
-    List<int[]> result = new ArrayList<>();
-    int idx = 0;
-    int newStart = newInterval[0];
-    int newEnd = newInterval[1];
-    while (idx < intervals.length && newStart > intervals[idx][0]) {
-      result.add(intervals[idx++]);
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        List<int[]> result = new ArrayList<>();
+        int idx = 0;
+        while (idx < intervals.length && intervals[idx][1] < newInterval[0]) {
+            result.add(intervals[idx++]);
+        }
+        while (idx < intervals.length && newInterval[1] >= intervals[idx][0]) {
+            newInterval[0] = Math.min(newInterval[0], intervals[idx][0]);
+            newInterval[1] = Math.max(newInterval[1], intervals[idx][1]);
+            idx++;
+        }
+        result.add(newInterval);
+        while (idx < intervals.length) {
+            result.add(intervals[idx++]);
+        }
+        return result.toArray(new int[result.size()][]);
     }
-    int[] currInterval = new int[2];
-    if (result.isEmpty() || result.get(result.size() - 1)[1] < newStart) {
-      result.add(newInterval);
-    } else {
-      currInterval = result.remove(result.size() - 1);
-      currInterval[1] = Math.max(currInterval[1], newEnd);
-      result.add(currInterval);
-    }
-    while (idx < intervals.length) {
-      currInterval = intervals[idx++];
-      int start = currInterval[0];
-      int end = currInterval[1];
-      if (result.get(result.size() - 1)[1] < start) {
-        result.add(currInterval);
-      } else {
-        currInterval = result.remove(result.size() - 1);
-        currInterval[1] = Math.max(currInterval[1], end);
-        result.add(currInterval);
-      }
-    }
-    return result.toArray(new int[result.size()][2]);
-  }
 }

From 25205b87a44faf2e93bbd658db93d834e1fe7b7e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 19 Mar 2024 17:43:37 -0700
Subject: [PATCH 1962/2175] Update Merge In Between Linked Lists.java

---
 Medium/Merge In Between Linked Lists.java | 39 ++++++++++-------------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/Medium/Merge In Between Linked Lists.java b/Medium/Merge In Between Linked Lists.java
index 5e3b814a..9f36b5a8 100644
--- a/Medium/Merge In Between Linked Lists.java	
+++ b/Medium/Merge In Between Linked Lists.java	
@@ -9,27 +9,22 @@
  * }
  */
 class Solution {
-  public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
-    ListNode currList1 = list1;
-    // Stop just before a and record the pointer
-    for (int i = 0; i < a - 1; i++) {
-      currList1 = currList1.next;
+    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
+        ListNode curr = list1;
+        for (int i = 1; i < a; i++) {
+            curr = curr.next;
+        }
+        ListNode start = curr;
+        for (int i = a - 1; i <= b; i++) {
+            curr = curr.next;
+        }
+        ListNode end = curr;
+        start.next = list2;
+        curr = list2;
+        while (curr.next != null) {
+            curr = curr.next;
+        }
+        curr.next = end;
+        return list1;
     }
-    ListNode currCopy = currList1;
-    // Cover a to b
-    for (int i = a; i <= b; i++) {
-      currList1 = currList1.next;
-    } 
-    // Record what is remaining after b
-    ListNode remaining = currList1.next;
-    // Find end of list2
-    ListNode list2End = list2;
-    while (list2End != null && list2End.next != null) {
-      list2End = list2End.next;
-    }
-    // Pointer manipulation
-    currCopy.next = list2;
-    list2End.next = remaining;
-    return list1;
-  }
 }

From d7bef6088335dd3c0ab9ee007605c45acba13137 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 22 Mar 2024 07:34:22 -0700
Subject: [PATCH 1963/2175] Update Palindrome Linked List.java

---
 Easy/Palindrome Linked List.java | 62 +++++++++++++++-----------------
 1 file changed, 29 insertions(+), 33 deletions(-)

diff --git a/Easy/Palindrome Linked List.java b/Easy/Palindrome Linked List.java
index 946427e6..11c23754 100644
--- a/Easy/Palindrome Linked List.java	
+++ b/Easy/Palindrome Linked List.java	
@@ -9,39 +9,35 @@
  * }
  */
 class Solution {
-  public boolean isPalindrome(ListNode head) {
-    if (head.next == null) {
-      return true;
+    public boolean isPalindrome(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        ListNode secondHalf = slow;
+        secondHalf = reverse(secondHalf);
+        ListNode firstHalf = head;
+        while (secondHalf != null && firstHalf != null) {
+            if (firstHalf.val != secondHalf.val) {
+                return false;
+            }
+            firstHalf = firstHalf.next;
+            secondHalf = secondHalf.next;
+        }
+        return true;
     }
-    ListNode slow = head;
-    ListNode fast = head;
-    ListNode prev = null;
-    while (fast != null && fast.next != null) {
-      prev = slow;
-      fast = fast.next.next;
-      slow = slow.next;
+
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
     }
-    ListNode revNode = reverse(slow);
-    while (revNode != null) {
-      if (revNode.val != head.val) {
-        return false;
-      }
-      revNode = revNode.next;
-      head = head.next;
-    }
-    return true;
-  }
-  
-  private ListNode reverse(ListNode node) {
-    ListNode prev = null;
-    ListNode curr = node;
-    ListNode next = node;
-    while (curr != null) {
-      next = curr.next;
-      curr.next = prev;
-      prev = curr;
-      curr = next;
-    }
-    return prev;
-  }
 }

From 72b581013e7ef90f5eb6dd41217441b74f3f9ee9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 23 Mar 2024 10:02:57 -0700
Subject: [PATCH 1964/2175] Update Reorder List.java

---
 Medium/Reorder List.java | 58 ++++++++++++++++++++--------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/Medium/Reorder List.java b/Medium/Reorder List.java
index 769a555d..99b9ea19 100644
--- a/Medium/Reorder List.java	
+++ b/Medium/Reorder List.java	
@@ -9,35 +9,35 @@
  * }
  */
 class Solution {
-  public void reorderList(ListNode head) {
-    ListNode slow = head;
-    ListNode fast = head;
-    while (fast != null && fast.next != null) {
-      slow = slow.next;
-      fast = fast.next.next;
+    public void reorderList(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        ListNode secondHalf = reverse(slow.next);
+        slow.next = null;
+        ListNode firstHalf = head;
+        while (firstHalf != null && secondHalf != null) {
+            ListNode firstNext = firstHalf.next;
+            ListNode secondNext = secondHalf.next;
+            firstHalf.next = secondHalf;
+            secondHalf.next = firstNext;
+            firstHalf = firstNext;
+            secondHalf = secondNext;
+        }
     }
-    ListNode secondHalf = reverse(slow.next);
-    slow.next = null;
-    ListNode firstHalf = head;
-    while (firstHalf != null && secondHalf != null) {
-      ListNode firstHalfNext = firstHalf.next;
-      ListNode secondHalfNext = secondHalf.next;
-      firstHalf.next = secondHalf;
-      secondHalf.next = firstHalfNext;
-      firstHalf = firstHalfNext;
-      secondHalf = secondHalfNext;
+
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
     }
-  }
-  
-  private ListNode reverse(ListNode node) {
-    ListNode curr = node;
-    ListNode prev = null;
-    while (curr != null) {
-      ListNode next = curr.next;
-      curr.next = prev;
-      prev = curr;
-      curr = next;
-    }
-    return prev;
-  }
 }

From 664bac5a16760e895044e8afe0dacfabe9349ecd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 26 Mar 2024 07:48:20 -0700
Subject: [PATCH 1965/2175] Update First Missing Positive.java

---
 Hard/First Missing Positive.java | 49 ++++++++++++++++----------------
 1 file changed, 24 insertions(+), 25 deletions(-)

diff --git a/Hard/First Missing Positive.java b/Hard/First Missing Positive.java
index 91b5b6fd..3b501319 100644
--- a/Hard/First Missing Positive.java	
+++ b/Hard/First Missing Positive.java	
@@ -1,28 +1,27 @@
 class Solution {
-  public int firstMissingPositive(int[] nums) {
-    int n = nums.length;
-    int idx = 0;
-    while (idx < n) {
-      if (nums[idx] > 0 && nums[idx] < n && nums[nums[idx]] != nums[idx]) {
-        swap(nums, idx, nums[idx]);
-      }
-      else {
-        idx++;
-      }
+    public int firstMissingPositive(int[] nums) {
+        int n = nums.length;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] < 0) {
+                nums[i] = 0;
+            }
+        } 
+        for (int i = 0; i < n; i++) {
+            int val = Math.abs(nums[i]);
+            if (val >= 1 && val <= n) {
+                int idx = val - 1;
+                if (nums[idx] > 0) {
+                    nums[idx] *= -1;
+                } else if (nums[idx] == 0) {
+                    nums[idx] = -1 * (n + 1);
+                }
+            }
+        }
+        for (int i = 1; i <= n; i++) {
+            if (nums[i - 1] >= 0) {
+                return i;
+            }
+        }  
+        return n + 1; 
     }
-    idx = 1;
-    while (idx < n && nums[idx] == idx) {
-      idx++;
-    }
-    if (n == 0 || idx < n) {
-      return idx;
-    }
-    return nums[0] == idx ? idx + 1 : idx;
-  }
-  
-  private void swap(int[] nums, int i, int j) {
-    int temp = nums[i];
-    nums[i] = nums[j];
-    nums[j] = temp;
-  }
 }

From 8b593fc716250d0856671800b0551d6f12fe40b4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 27 Mar 2024 07:20:23 -0700
Subject: [PATCH 1966/2175] Update Subarray Product Less Than K.java

---
 Medium/Subarray Product Less Than K.java | 32 +++++++++++++-----------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/Medium/Subarray Product Less Than K.java b/Medium/Subarray Product Less Than K.java
index 68ba3e13..3f53dc87 100644
--- a/Medium/Subarray Product Less Than K.java	
+++ b/Medium/Subarray Product Less Than K.java	
@@ -1,18 +1,20 @@
 class Solution {
-  public int numSubarrayProductLessThanK(int[] nums, int k) {
-    if (k <= 1) {
-      return 0;
+    public int numSubarrayProductLessThanK(int[] nums, int k) {
+        if (k <= 1) {
+            return 0;
+        }
+        int prod = 1;
+        int start = 0;
+        int end = 0;
+        int n = nums.length;
+        int result = 0;
+        while (end < n) {
+            prod *= nums[end++];
+            while (start < end && prod >= k) {
+                prod /= nums[start++];
+            }
+            result += end - start;
+        }
+        return result;
     }
-    int prod = 1;
-    int ans = 0;
-    int left = 0;
-    for (int right = 0; right < nums.length; right++) {
-      prod *= nums[right];
-      while (prod >= k) {
-        prod /= nums[left++];
-      }
-      ans += right - left + 1;
-    }
-    return ans;
-  }
 }

From ff9986ab91a0879c360e7b1d56a7090c866c3ea9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 27 Mar 2024 07:25:40 -0700
Subject: [PATCH 1967/2175] Create Maximum Length Substring With Two
 Occurrences.java

---
 ...Length Substring With Two Occurrences.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Maximum Length Substring With Two Occurrences.java

diff --git a/Easy/Maximum Length Substring With Two Occurrences.java b/Easy/Maximum Length Substring With Two Occurrences.java
new file mode 100644
index 00000000..44e281b1
--- /dev/null
+++ b/Easy/Maximum Length Substring With Two Occurrences.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maximumLengthSubstring(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int start = 0;
+        int end = 0;
+        int n = s.length();
+        int result = 0;
+        while (end < n) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            while (start <= end && map.get(s.charAt(end)) > 2) {
+                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
+                start++;
+            }
+            end++;
+            result = Math.max(result, end - start);
+        }
+        return result;
+    }
+}

From 530e5b4b75ac9062b59a9924c5366cfb52aa7e3c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 27 Mar 2024 17:38:50 -0700
Subject: [PATCH 1968/2175] Create Length of Longest Subarray With at Most K
 Frequency.java

---
 ...est Subarray With at Most K Frequency.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Length of Longest Subarray With at Most K Frequency.java

diff --git a/Medium/Length of Longest Subarray With at Most K Frequency.java b/Medium/Length of Longest Subarray With at Most K Frequency.java
new file mode 100644
index 00000000..82d8f62d
--- /dev/null
+++ b/Medium/Length of Longest Subarray With at Most K Frequency.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxSubarrayLength(int[] nums, int k) {
+        int start = 0;
+        int end = 0;
+        int result = 0;
+        int n = nums.length;
+        Map<Integer, Integer> map = new HashMap<>();
+        while (end < n) {
+            map.put(nums[end], map.getOrDefault(nums[end], 0) + 1);
+            while (start < end && map.get(nums[end]) > k) {
+                map.put(nums[start], map.get(nums[start]) - 1);
+                start++;
+            }
+            end++;
+            result = Math.max(result, end - start);
+        }
+        return result;
+    }
+}

From 52cbe7ef9fa491f84d99711ec99e9e2e2e1445b4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 28 Mar 2024 17:33:01 -0700
Subject: [PATCH 1969/2175] Create Count Subarrays Where Max Element Appears at
 Least K Times.java

---
 ... Max Element Appears at Least K Times.java | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Count Subarrays Where Max Element Appears at Least K Times.java

diff --git a/Medium/Count Subarrays Where Max Element Appears at Least K Times.java b/Medium/Count Subarrays Where Max Element Appears at Least K Times.java
new file mode 100644
index 00000000..d917693d
--- /dev/null
+++ b/Medium/Count Subarrays Where Max Element Appears at Least K Times.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int maxElement = 0;
+        for (int num : nums) {
+            maxElement = Math.max(maxElement, num);
+        }
+        long result = 0;
+        int start = 0;
+        int maxElementsInWindow = 0;
+        for (int end = 0; end < nums.length; end++) {
+            if (nums[end] == maxElement) {
+                maxElementsInWindow++;
+            }
+            while (k == maxElementsInWindow) {
+                if (nums[start] == maxElement) {
+                    maxElementsInWindow--;
+                }
+                start++;
+            }
+            result += start;
+        }
+        return result;
+    }
+}

From a79f2a05a0beceb70618d587dffb0962fb9a06e6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 30 Mar 2024 08:30:07 -0700
Subject: [PATCH 1970/2175] Update Subarrays with K Different Integers.java

---
 Hard/Subarrays with K Different Integers.java | 44 ++++++++-----------
 1 file changed, 19 insertions(+), 25 deletions(-)

diff --git a/Hard/Subarrays with K Different Integers.java b/Hard/Subarrays with K Different Integers.java
index 42224709..0a1d5559 100644
--- a/Hard/Subarrays with K Different Integers.java	
+++ b/Hard/Subarrays with K Different Integers.java	
@@ -1,29 +1,23 @@
 class Solution {
-  public int subarraysWithKDistinct(int[] A, int K) {
-    return atMostK(A, K) - atMostK(A, K - 1);
-  }
-  
-  private int atMostK(int[] A, int K) {
-    int start = 0;
-    int end = 0;
-    int n = A.length;
-    Map<Integer, Integer> map = new HashMap<>();
-    int count = 0;
-    while (end < n) {
-      if (map.getOrDefault(A[end], 0) == 0) {
-        K--;
-      }
-      map.put(A[end], map.getOrDefault(A[end], 0) + 1);
-      while (K < 0) {
-        map.put(A[start], map.getOrDefault(A[start], 0) - 1);
-        if (map.get(A[start]) == 0) {
-          K++;
+    public int subarraysWithKDistinct(int[] nums, int k) {
+        return slidingWindowAtMost(nums, k) - slidingWindowAtMost(nums, k - 1);
+    }
+
+    private int slidingWindowAtMost(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int left = 0;
+        int count = 0;
+        for (int right = 0; right < nums.length; right++) {
+            map.put(nums[right], map.getOrDefault(nums[right], 0) + 1);
+            while (map.size() > k) {
+                map.put(nums[left], map.get(nums[left]) - 1);
+                if (map.get(nums[left]) == 0) {
+                    map.remove(nums[left]);
+                }
+                left++;
+            }
+            count += right - left + 1;
         }
-        start++;
-      }
-      count += end - start + 1;
-      end++;
+        return count;
     }
-    return count;
-  }
 }

From 74ecc816f061f2f8b20ed25592b5bb82da1eebef Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Mar 2024 07:29:37 -0700
Subject: [PATCH 1971/2175] Create Harshad Number.java

---
 Easy/Harshad Number.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Harshad Number.java

diff --git a/Easy/Harshad Number.java b/Easy/Harshad Number.java
new file mode 100644
index 00000000..c02c40bf
--- /dev/null
+++ b/Easy/Harshad Number.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int sumOfTheDigitsOfHarshadNumber(int x) {
+        int digitSum = getDigitSum(x);
+        return x % digitSum == 0 ? digitSum : -1;
+    }
+
+    private static int getDigitSum(int num) {
+        int sum = 0;
+        while (num > 0) {
+            sum += num % 10;
+            num /= 10;
+        }
+        return sum;
+    }
+}

From 8688def7aadb96379ae1585b8066ef0c4129fee8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Mar 2024 07:33:58 -0700
Subject: [PATCH 1972/2175] Create Shortest Subarray With OR at Least K I.java

---
 .../Shortest Subarray With OR at Least K I.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Shortest Subarray With OR at Least K I.java

diff --git a/Easy/Shortest Subarray With OR at Least K I.java b/Easy/Shortest Subarray With OR at Least K I.java
new file mode 100644
index 00000000..0032852b
--- /dev/null
+++ b/Easy/Shortest Subarray With OR at Least K I.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int minimumSubarrayLength(int[] nums, int k) {
+        int n = nums.length;
+        int result = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            int curr = 0;
+            for (int j = i; j < n; j++) {
+                curr |= nums[j];
+                if (curr >= k) {
+                    result = Math.min(result, j - i + 1);
+                    break;
+                }
+            }
+        }
+        return result == Integer.MAX_VALUE ? -1 : result;
+    }
+}

From b9cb5afa67287356efd12abdfc62adca0cdcb505 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Mar 2024 07:43:09 -0700
Subject: [PATCH 1973/2175] Create Minimum Levels to Gain More Points.java

---
 Medium/Minimum Levels to Gain More Points.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Minimum Levels to Gain More Points.java

diff --git a/Medium/Minimum Levels to Gain More Points.java b/Medium/Minimum Levels to Gain More Points.java
new file mode 100644
index 00000000..c7fd7222
--- /dev/null
+++ b/Medium/Minimum Levels to Gain More Points.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int minimumLevels(int[] possible) {
+        int n = possible.length;
+        int totalScore = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            totalScore += possible[i] == 1 ? 1 : -1;
+        }
+        int score = 0;
+        for (int i = 0; i < n - 1; i++) {
+            score += possible[i] == 1 ? 1 : -1;
+            if (score > totalScore - score) {
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+}

From 01afcab2ae6b64f994a82b049ce5a3a78305ebb7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Mar 2024 07:49:08 -0700
Subject: [PATCH 1974/2175] Create Water Bottles II.java

---
 Medium/Water Bottles II.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Water Bottles II.java

diff --git a/Medium/Water Bottles II.java b/Medium/Water Bottles II.java
new file mode 100644
index 00000000..d9205f31
--- /dev/null
+++ b/Medium/Water Bottles II.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public int maxBottlesDrunk(int numBottles, int numExchange) {
+        int total = numBottles;
+        while (numBottles >= numExchange) {
+            numBottles -= numExchange;
+            numExchange++;
+            total++;
+            numBottles++;
+        }
+        return total;
+    }
+}

From 06832e167e97e1c0ca6f86aa0c8c54dc321a3c31 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 31 Mar 2024 07:49:25 -0700
Subject: [PATCH 1975/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c4fd5e63..a90fb07e 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 1500+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1600+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count

From 1e074c2fc9157c916f40e745ce9bd6d9f9b73245 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 2 Apr 2024 06:15:30 -0700
Subject: [PATCH 1976/2175] Update Isomorphic Strings.java

---
 Easy/Isomorphic Strings.java | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/Easy/Isomorphic Strings.java b/Easy/Isomorphic Strings.java
index 6b870650..b9813b64 100644
--- a/Easy/Isomorphic Strings.java	
+++ b/Easy/Isomorphic Strings.java	
@@ -1,12 +1,18 @@
 class Solution {
-  public boolean isIsomorphic(String s, String t) {
-    int[] position = new int[512];
-    for (int i = 0; i < s.length(); i++) {
-      if (position[s.charAt(i)] != position[t.charAt(i) + 256]) {
-        return false;
-      }
-      position[s.charAt(i)] = position[t.charAt(i) + 256] = i + 1;
+    public boolean isIsomorphic(String s, String t) {
+        return mapString(s).equals(mapString(t));
+    }
+
+    private static String mapString(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int count = 0;
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (!map.containsKey(c)) {
+                map.put(c, count++);
+            }
+            sb.append(map.get(c)).append("|");
+        }
+        return sb.toString();
     }
-    return true;
-  }
 }

From 02a4635a3dc7bcbee0ce07e31339840db4a2ea4f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 4 Apr 2024 06:40:55 -0700
Subject: [PATCH 1977/2175] Update Maximum Nesting Depth of the
 Parentheses.java

---
 ...ximum Nesting Depth of the Parentheses.java | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/Easy/Maximum Nesting Depth of the Parentheses.java b/Easy/Maximum Nesting Depth of the Parentheses.java
index 19a50736..8ce9eac2 100644
--- a/Easy/Maximum Nesting Depth of the Parentheses.java	
+++ b/Easy/Maximum Nesting Depth of the Parentheses.java	
@@ -1,11 +1,13 @@
 class Solution {
-  public int maxDepth(String s) {
-    int currCount = 0;
-    int maxCount = 0;
-    for (char c : s.toCharArray()) {
-      currCount += c == '(' ? 1 : (c == ')' ? -1 : 0);
-      maxCount = Math.max(maxCount, currCount);
+    public int maxDepth(String s) {
+        int count = 0;
+        int result = 0;
+        for (char c : s.toCharArray()) {
+            if (c == '(' || c == ')') {
+                count += c == '(' ? 1 : -1;
+            }
+            result = Math.max(result, count);
+        }
+        return result;
     }
-    return maxCount;
-  }
 }

From 0b9bea2ac20b3e7f0ac3debde30d3885926ac8ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 5 Apr 2024 06:56:58 -0700
Subject: [PATCH 1978/2175] Update Make The String Great.java

---
 Easy/Make The String Great.java | 34 +++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/Easy/Make The String Great.java b/Easy/Make The String Great.java
index a7cb7882..32b4684a 100644
--- a/Easy/Make The String Great.java	
+++ b/Easy/Make The String Great.java	
@@ -1,18 +1,24 @@
 class Solution {
-  public String makeGood(String s) {
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-      if (!stack.isEmpty() && Math.abs(stack.peek() - c) == 32) {
-        stack.pop();
-      }
-      else {
-        stack.push(c);
-      }
+    public String makeGood(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && isBad(c, stack.peek())) {
+                stack.pop();
+                continue;
+            }
+            stack.push(c);
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
     }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append(stack.pop());
+
+    private static boolean isBad(char c1, char c2) {
+        if (c1 == c2) {
+            return false;
+        }
+        return Character.toLowerCase(c1) == Character.toLowerCase(c2);
     }
-    return sb.reverse().toString();
-  }
 }

From 60c654266ebd4e48c453ae1529a5e767d11a1fc6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 5 Apr 2024 17:17:04 -0700
Subject: [PATCH 1979/2175] Update Minimum Remove to Make Valid
 Parentheses.java

---
 ...imum Remove to Make Valid Parentheses.java | 45 ++++++++++---------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/Medium/Minimum Remove to Make Valid Parentheses.java b/Medium/Minimum Remove to Make Valid Parentheses.java
index 45734d11..7d5be988 100644
--- a/Medium/Minimum Remove to Make Valid Parentheses.java	
+++ b/Medium/Minimum Remove to Make Valid Parentheses.java	
@@ -1,27 +1,28 @@
 class Solution {
-  public String minRemoveToMakeValid(String s) {
-    Stack<Integer> stack = new Stack<>();
-    Set<Integer> validIndexes = new HashSet<>();
-    for (int i = 0; i < s.length(); i++) {
-      if (s.charAt(i) == '(') {
-        stack.add(i);
-      } else if (s.charAt(i) == ')') {
-        if (!stack.isEmpty()) {
-          validIndexes.add(stack.pop());
-          validIndexes.add(i);
+    public String minRemoveToMakeValid(String s) {
+        char[] letters = s.toCharArray();
+        Stack<Integer> stack = new Stack<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c == '(') {
+                stack.push(i);
+            } else if (c == ')') {
+                if (stack.isEmpty()) {
+                    letters[i] = '-';
+                } else {
+                    stack.pop();
+                }
+            }
         }
-      }
-    }
-    StringBuilder sb = new StringBuilder();
-    for (int i = 0; i < s.length(); i++) {
-      if (s.charAt(i) == '(' || s.charAt(i) == ')') {
-        if (validIndexes.contains(i)) {
-          sb.append(s.charAt(i));
+        while (!stack.isEmpty()) {
+            letters[stack.pop()] = '-';
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char c : letters) {
+            if (c != '-') {
+                sb.append(c);
+            }
         }
-      } else {
-        sb.append(s.charAt(i));
-      }
+        return sb.toString();
     }
-    return sb.toString();
-  }
 }

From adeed10feaa5927ac9055ca0912690250abe5942 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 14 Apr 2024 15:56:31 -0700
Subject: [PATCH 1980/2175] Create Score of a String.java

---
 Easy/Score of a String.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Score of a String.java

diff --git a/Easy/Score of a String.java b/Easy/Score of a String.java
new file mode 100644
index 00000000..fafcca05
--- /dev/null
+++ b/Easy/Score of a String.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public int scoreOfString(String s) {
+        int score = 0;
+        for (int i = 1; i < s.length(); i++) {
+            score += Math.abs(s.charAt(i) - s.charAt(i - 1));
+        }
+        return score;
+    }
+}

From 21b2ab22036c4aaf54a4faffcbf504ecf9c1c334 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 20 Apr 2024 08:51:46 -0700
Subject: [PATCH 1981/2175] Create Find All Groups of Farmland.java

---
 Medium/Find All Groups of Farmland.java | 49 +++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 Medium/Find All Groups of Farmland.java

diff --git a/Medium/Find All Groups of Farmland.java b/Medium/Find All Groups of Farmland.java
new file mode 100644
index 00000000..130db6a1
--- /dev/null
+++ b/Medium/Find All Groups of Farmland.java	
@@ -0,0 +1,49 @@
+class Solution {
+
+    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+    public int[][] findFarmland(int[][] land) {
+        int rows = land.length;
+        int cols = land[0].length;
+        boolean[][] visited = new boolean[rows][cols];
+        List<int[]> result = new ArrayList<>();
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (land[i][j] == 1 && !visited[i][j]) {
+                    traverse(land, i, j, visited, result);
+                }
+            }
+        }
+        return result.stream()
+                .map(int[]::clone)
+                .toArray(int[][]::new);
+    }
+
+    private static void traverse(int[][] land, int i, int j, boolean[][] visited, List<int[]> result) {
+        int rows = land.length;
+        int cols = land[0].length;
+        Queue<int[]> queue = new LinkedList<>();
+        int[] leftMost = {i, j};
+        int[] rightMost = {i, j};
+        queue.add(new int[]{i, j});
+        visited[i][j] = true;
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int x = removed[0];
+            int y = removed[1];
+            leftMost[0] = Math.min(leftMost[0], x);
+            leftMost[1] = Math.min(leftMost[1], y);
+            rightMost[0] = Math.max(rightMost[0], x);
+            rightMost[1] = Math.max(rightMost[1], y);
+            for (int[] dir : DIRS) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                if (newX >= 0 && newY >= 0 && newX < rows && newY < cols && !visited[newX][newY] && land[newX][newY] == 1) {
+                    queue.add(new int[]{newX, newY});
+                    visited[newX][newY] = true;
+                }
+            }
+        }
+        result.add(new int[]{leftMost[0], leftMost[1], rightMost[0], rightMost[1]});
+    }
+}

From 3e2b8bf6164d6751ebdc3e6f1394890237652c46 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 21 Apr 2024 08:43:27 -0700
Subject: [PATCH 1982/2175] Create Count the Number of Special Characters
 I.java

---
 ...nt the Number of Special Characters I.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Count the Number of Special Characters I.java

diff --git a/Easy/Count the Number of Special Characters I.java b/Easy/Count the Number of Special Characters I.java
new file mode 100644
index 00000000..44c9950f
--- /dev/null
+++ b/Easy/Count the Number of Special Characters I.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int numberOfSpecialChars(String word) {
+        boolean[] upperPresent = new boolean[26];
+        boolean[] lowerPresent = new boolean[26];
+        for (char c : word.toCharArray()) {
+            if (Character.isUpperCase(c)) {
+                upperPresent[c - 'A'] = true;
+            } else {
+                lowerPresent[c - 'a'] = true;
+            }
+        }
+        int count = 0;
+        for (int i = 0; i < 26; i++) {
+            if (upperPresent[i] && lowerPresent[i]) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

From e1fcc313d62a9e158251ff7c0a2c932e96116917 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Apr 2024 08:07:39 -0700
Subject: [PATCH 1983/2175] Update Open The Lock.java

---
 Medium/Open The Lock.java | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/Medium/Open The Lock.java b/Medium/Open The Lock.java
index 926e8521..f692f0ba 100644
--- a/Medium/Open The Lock.java	
+++ b/Medium/Open The Lock.java	
@@ -1,40 +1,38 @@
 class Solution {
     public int openLock(String[] deadends, String target) {
         Set<String> deadEndSet = new HashSet<>(Arrays.asList(deadends));
-        if (deadEndSet.contains(target) || deadEndSet.contains("0000")) {
+        String startingPoint = "0000";
+        if (deadEndSet.contains(startingPoint)) {
             return -1;
         }
         Queue<String> queue = new LinkedList<>();
-        Set<String> seen = new HashSet<>();
-        queue.add("0000");
-        seen.add("0000");
-        int steps = 0;
+        Set<String> visited = new HashSet<>();
+        queue.add(startingPoint);
+        visited.add(startingPoint);
+        int attempts = 0;
         int[] rotations = {-1, 1};
         while (!queue.isEmpty()) {
             int size = queue.size();
             for (int i = 0; i < size; i++) {
                 String removed = queue.remove();
                 if (removed.equals(target)) {
-                    return steps;
+                    return attempts;
                 }
                 if (deadEndSet.contains(removed)) {
                     continue;
                 }
                 for (int j = 0; j < 4; j++) {
                     for (int rotation : rotations) {
-                        int changedVal = ((removed.charAt(j) - '0') + rotation + 10) % 10;
-                        String newRotation = new StringBuilder()
-                                                    .append(removed.substring(0,j))                                                                                         .append(changedVal)
-                                                    .append(removed.substring(j + 1))
-                                                    .toString();
-                        if (!seen.contains(newRotation)) {
-                            seen.add(newRotation);
+                        int newValue = ((removed.charAt(j) - '0') + rotation + 10) % 10;
+                        String newRotation = removed.substring(0, j) + newValue + removed.substring(j + 1);
+                        if (!visited.contains(newRotation)) {
+                            visited.add(newRotation);
                             queue.add(newRotation);
                         }
                     }
                 }
             }
-            steps++;
+            attempts++;
         }
         return -1;
     }

From 54c637a6a466971146178fac306a5743e93b4e04 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Apr 2024 12:20:02 -0700
Subject: [PATCH 1984/2175] Create Make a Square with the Same Color.java

---
 Easy/Make a Square with the Same Color.java | 40 +++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 Easy/Make a Square with the Same Color.java

diff --git a/Easy/Make a Square with the Same Color.java b/Easy/Make a Square with the Same Color.java
new file mode 100644
index 00000000..2f5524d8
--- /dev/null
+++ b/Easy/Make a Square with the Same Color.java	
@@ -0,0 +1,40 @@
+class Solution {
+
+    int[][] DIRS = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
+
+    public boolean canMakeSquare(char[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (isPossible(grid, i, j, rows, cols)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean isPossible(char[][] grid, int i, int j, int rows, int cols) {
+        int white = 0;
+        int black = 0;
+        int invalid = 0;
+        for (int[] dir : DIRS) {
+            int newX = i + dir[0];
+            int newY = j + dir[1];
+            if (newX >= 0 && newY >= 0 && newX < rows && newY < cols) {
+                white += grid[newX][newY] == 'W' ? 1 : 0;
+                black += grid[newX][newY] == 'B' ? 1 : 0;
+            } else {
+                invalid++;
+            }
+        }
+        if (invalid > 0) {
+            return false;
+        }
+        if (white == 4 || black == 4) {
+            return true;
+        }
+        return white == 1 || black == 1;
+    }
+}

From d3bf7af949dd8ae6070428bdef205271b2ddaaf8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Apr 2024 12:23:29 -0700
Subject: [PATCH 1985/2175] Create Find the Integer Added to Array I.java

---
 Easy/Find the Integer Added to Array I.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Find the Integer Added to Array I.java

diff --git a/Easy/Find the Integer Added to Array I.java b/Easy/Find the Integer Added to Array I.java
new file mode 100644
index 00000000..c5d551e3
--- /dev/null
+++ b/Easy/Find the Integer Added to Array I.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int addedInteger(int[] nums1, int[] nums2) {
+        int minOne = nums1[0];
+        int minTwo = nums2[0];
+        for (int i = 0; i < nums1.length; i++) {
+            minOne = Math.min(minOne, nums1[i]);
+            minTwo = Math.min(minTwo, nums2[i]);
+        }
+        return minTwo - minOne;
+    }
+}

From 87b15483c21a902223014ca5058913891334648e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 2 May 2024 06:48:01 -0700
Subject: [PATCH 1986/2175] Create Right Triangles.java

---
 Medium/Right Triangles.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Right Triangles.java

diff --git a/Medium/Right Triangles.java b/Medium/Right Triangles.java
new file mode 100644
index 00000000..d94804b3
--- /dev/null
+++ b/Medium/Right Triangles.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public long numberOfRightTriangles(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int[] rowCount = new int[rows];
+        int[] colCount = new int[cols];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] == 1) {
+                    rowCount[i]++;
+                    colCount[j]++;
+                }
+            }
+        }
+        long triangles = 0;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] == 1) {
+                    triangles += (rowCount[i] - 1) * (colCount[j] - 1);
+                }
+            }
+        }
+        return triangles;
+    }
+}

From 3830eea78d5a4f45645f7c401bb8da7e0253a4aa Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 5 May 2024 16:42:39 -0700
Subject: [PATCH 1987/2175] Create Valid Word.java

---
 Easy/Valid Word.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Valid Word.java

diff --git a/Easy/Valid Word.java b/Easy/Valid Word.java
new file mode 100644
index 00000000..c9611bbd
--- /dev/null
+++ b/Easy/Valid Word.java	
@@ -0,0 +1,21 @@
+class Solution {
+
+    private static final Set<Character> VOWELS = Set.of('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U');
+
+    public boolean isValid(String word) {
+        boolean vowelFound = false;
+        boolean consonantFound = false;
+        for (char c : word.toCharArray()) {
+            if (Character.isLetter(c)) {
+                if (VOWELS.contains(c)) {
+                    vowelFound = true;
+                } else {
+                    consonantFound = true;
+                }
+            } else if (!Character.isDigit(c)) {
+                return false;
+            }
+        }
+        return word.length() >= 3 && vowelFound && consonantFound;
+    }
+}

From 1f3c0a22ddaaf3eaff62d92b893fecbddb9a28d2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 6 May 2024 19:45:36 -0700
Subject: [PATCH 1988/2175] Create Double a Number Represented as a Linked
 List.java

---
 ...a Number Represented as a Linked List.java | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 Medium/Double a Number Represented as a Linked List.java

diff --git a/Medium/Double a Number Represented as a Linked List.java b/Medium/Double a Number Represented as a Linked List.java
new file mode 100644
index 00000000..9e2bcbaa
--- /dev/null
+++ b/Medium/Double a Number Represented as a Linked List.java	
@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode doubleIt(ListNode head) {
+        ListNode rev = reverse(head);
+        ListNode curr = rev;
+        int carry = 0;
+        while (curr != null) {
+            int val = curr.val * 2 + carry;
+            carry = val / 10;
+            curr.val = val % 10;
+            if (curr.next == null && carry != 0) {
+                curr.next = new ListNode(carry);
+                break;
+            }
+            curr = curr.next;
+        }
+        return reverse(rev);
+    }
+
+    private ListNode reverse(ListNode curr) {
+        ListNode next = null;
+        ListNode prev = null;
+        while (curr != null) {
+            next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
+    }
+}

From 84dbd76dbe62e9fba04a461f29e5ace81f6359ab Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 May 2024 08:01:29 -0700
Subject: [PATCH 1989/2175] Create All O`one Data Structure.java

---
 Hard/All O`one Data Structure.java | 108 +++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 Hard/All O`one Data Structure.java

diff --git a/Hard/All O`one Data Structure.java b/Hard/All O`one Data Structure.java
new file mode 100644
index 00000000..211e4f01
--- /dev/null
+++ b/Hard/All O`one Data Structure.java	
@@ -0,0 +1,108 @@
+class AllOne {
+    private final NodeList head;
+    private final NodeList tail;
+    private final Map<Integer, NodeList> countToNodeMapping;
+    private final Map<String, Integer> keyToCountMapping;
+
+    public AllOne() {
+        head = new NodeList(Integer.MIN_VALUE);
+        tail = new NodeList(Integer.MAX_VALUE);
+        head.next = tail;
+        tail.prev = head;
+        countToNodeMapping = new HashMap<>();
+        keyToCountMapping = new HashMap<>();
+    }
+
+    public void inc(String key) {
+        if (keyToCountMapping.containsKey(key)) {
+            updateKey(key, 1);
+        } else {
+            keyToCountMapping.put(key, 1);
+            if (head.next.count != 1) {
+                addNodeAfter(new NodeList(1), head);
+            }
+            head.next.keys.add(key);
+            countToNodeMapping.put(1, head.next);
+        }
+    }
+
+    public void dec(String key) {
+        if (keyToCountMapping.containsKey(key)) {
+            int count = keyToCountMapping.get(key);
+            if (count == 1) {
+                keyToCountMapping.remove(key);
+                removeKey(countToNodeMapping.get(count), key);
+            } else {
+                updateKey(key, -1);
+            }
+        }
+    }
+
+    public String getMaxKey() {
+        return tail.prev == head ? "" : tail.prev.keys.iterator().next();
+    }
+
+    public String getMinKey() {
+        return head.next == tail ? "" : head.next.keys.iterator().next();
+    }
+
+    private void updateKey(String key, int diff) {
+        int count = keyToCountMapping.get(key);
+        keyToCountMapping.put(key, count + diff);
+        NodeList currNode = countToNodeMapping.get(count);
+        NodeList newNode;
+        if (countToNodeMapping.containsKey(count + diff)) {
+            newNode = countToNodeMapping.get(count + diff);
+        } else {
+            newNode = new NodeList(count + diff);
+            countToNodeMapping.put(count + diff, newNode);
+            // If diff == 1 then new node will have count greater than currNode else it will have count less than currNode
+            addNodeAfter(newNode, diff == 1 ? currNode : currNode.prev);
+        }
+        newNode.keys.add(key);
+        removeKey(currNode, key);
+    }
+
+    private void removeKey(NodeList nodeList, String key) {
+        nodeList.keys.remove(key);
+        if (nodeList.keys.isEmpty()) {
+            removeNodeList(nodeList);
+            countToNodeMapping.remove(nodeList.count);
+        }
+    }
+
+    private void removeNodeList(NodeList nodeList) {
+        nodeList.prev.next = nodeList.next;
+        nodeList.next.prev = nodeList.prev;
+        nodeList.next = null;
+        nodeList.prev = null;
+    }
+
+    private void addNodeAfter(NodeList node, NodeList prevNode) {
+        node.prev = prevNode;
+        node.next = prevNode.next;
+        prevNode.next.prev = node;
+        prevNode.next = node;
+    }
+
+    private static class NodeList {
+        int count;
+        Set<String> keys;
+        NodeList next;
+        NodeList prev;
+
+        public NodeList(int count) {
+            this.count = count;
+            keys = new HashSet<>();
+        }
+    }
+}
+
+/**
+ * Your AllOne object will be instantiated and called as such:
+ * AllOne obj = new AllOne();
+ * obj.inc(key);
+ * obj.dec(key);
+ * String param_3 = obj.getMaxKey();
+ * String param_4 = obj.getMinKey();
+ */

From 81ceecf8e1c2faa599d807c92e532642856d1a6b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 9 May 2024 08:07:32 -0700
Subject: [PATCH 1990/2175] Create Maximize Happiness of Selected Children.java

---
 .../Maximize Happiness of Selected Children.java  | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Maximize Happiness of Selected Children.java

diff --git a/Medium/Maximize Happiness of Selected Children.java b/Medium/Maximize Happiness of Selected Children.java
new file mode 100644
index 00000000..01e3aeff
--- /dev/null
+++ b/Medium/Maximize Happiness of Selected Children.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public long maximumHappinessSum(int[] happiness, int k) {
+        Arrays.sort(happiness);
+        int turnCount = 0;
+        long happinessSum = 0;
+        int idx = happiness.length - 1;
+        while (k-- > 0) {
+            int currentHappiness = Math.max(0, happiness[idx] - turnCount);
+            happinessSum += currentHappiness;
+            turnCount++;
+            idx--;
+        }
+        return happinessSum;
+    }
+}

From 076472a2df68fb1908dc23c50a07ffbaa92749a2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 May 2024 07:31:05 -0700
Subject: [PATCH 1991/2175] Create Check if Grid Satisfies Conditions.java

---
 Easy/Check if Grid Satisfies Conditions.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Check if Grid Satisfies Conditions.java

diff --git a/Easy/Check if Grid Satisfies Conditions.java b/Easy/Check if Grid Satisfies Conditions.java
new file mode 100644
index 00000000..93891460
--- /dev/null
+++ b/Easy/Check if Grid Satisfies Conditions.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public boolean satisfiesConditions(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (i + 1 < rows && grid[i][j] != grid[i + 1][j]) {
+                    return false;
+                }
+                if (j + 1 < cols && grid[i][j] == grid[i][j + 1]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

From f93fb78f11158ccf99e8af4c60c0867d57dde076 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 13 May 2024 07:14:12 -0700
Subject: [PATCH 1992/2175] Update Score After Flipping Matrix.java

---
 Medium/Score After Flipping Matrix.java | 66 ++++++++-----------------
 1 file changed, 20 insertions(+), 46 deletions(-)

diff --git a/Medium/Score After Flipping Matrix.java b/Medium/Score After Flipping Matrix.java
index c369309d..54c3f3ac 100644
--- a/Medium/Score After Flipping Matrix.java	
+++ b/Medium/Score After Flipping Matrix.java	
@@ -1,59 +1,33 @@
 class Solution {
-    public int matrixScore(int[][] A) {
-        for (int i=0; i<A.length; i++) {
-            int actualSum = getDecimalValue(A[i], false);
-            int toggledSum = getDecimalValue(A[i], true);
-            
-            if (toggledSum > actualSum) {
-                for (int j=0; j<A[i].length; j++) {
-                    A[i][j] ^= 1;
+    public int matrixScore(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        for (int i = 0; i < rows; i++) {
+            if (grid[i][0] == 0) {
+                for (int j = 0; j < cols; j++) {
+                    grid[i][j] = 1 - grid[i][j];
                 }
             }
         }
-        
-        for (int i=0; i<A[0].length; i++) {
-            int numZeroes = 0;
-            int numOnes = 0;
-            
-            for (int j=0; j<A.length; j++) {
-                if (A[j][i] == 1 ) {
-                    numOnes++;
-                }
-                else {
-                    numZeroes++;
+        for (int j = 1; j < cols; j++) {
+            int countZero = 0;
+            for (int[] row : grid) {
+                if (row[j] == 0) {
+                    countZero++;
                 }
             }
-            
-            if (numZeroes > numOnes) {
-                for (int j=0; j<A.length; j++) {
-                    A[j][i] ^= 1;
+            if(countZero > rows-countZero) {
+                for(int i = 0; i < rows; i++) {
+                    grid[i][j] = 1 - grid[i][j];
                 }
             }
         }
-        
-        int maxSum = 0;
-        for (int[] arr : A) {
-            maxSum += getDecimalValue(arr, false);
-        }
-        
-        return maxSum;
-    }
-    
-    private int getDecimalValue(int[] arr, boolean isToggled) {
-        int sum = 0;
-        int pow = 0;
-        
-        for (int i=arr.length-1; i>=0; i--) {
-            if (isToggled) {
-                sum += Math.pow(2, pow) * (arr[i] ^ 1);
-            }
-            else {
-                sum += Math.pow(2, pow) * arr[i];
+        int score = 0;
+        for (int[] row : grid) {
+            for (int j = 0; j < cols; j++) {
+                score += row[j] << (cols - j - 1);
             }
-            
-            pow++;
         }
-        
-        return sum;
+        return score;
     }
 }

From ba2453e99cc45ac28c447b4e0c50e97cf8dae161 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 19 May 2024 07:11:10 -0700
Subject: [PATCH 1993/2175] Create Special Array I.java

---
 Easy/Special Array I.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 Easy/Special Array I.java

diff --git a/Easy/Special Array I.java b/Easy/Special Array I.java
new file mode 100644
index 00000000..5057f626
--- /dev/null
+++ b/Easy/Special Array I.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean isArraySpecial(int[] nums) {
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] % 2 == nums[i - 1] % 2) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From fc9d892f1be05e0b508276ebfa9529de36b4dbdb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 21 May 2024 08:14:13 -0700
Subject: [PATCH 1994/2175] Update Minimum Knight Moves.java

---
 Medium/Minimum Knight Moves.java | 52 ++++++++++++++++----------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/Medium/Minimum Knight Moves.java b/Medium/Minimum Knight Moves.java
index e1352ac4..35759df8 100644
--- a/Medium/Minimum Knight Moves.java	
+++ b/Medium/Minimum Knight Moves.java	
@@ -1,30 +1,30 @@
 class Solution {
-  private final int[][] DIRS = {{1, 2}, {2, 1}, {1, -2}, {-2, 1}, {2, -1}, {-2, -1}, {-1, -2}, {-1, 2}};
-  
-  public int minKnightMoves(int x, int y) {
-    int numOfSteps = 0;
-    boolean[][] visited = new boolean[607][607];
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{0, 0});
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        if (removed[0] == x && removed[1] == y) {
-          return numOfSteps;
+
+    private static final int[][] MOVES = {{1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}};
+
+    public int minKnightMoves(int x, int y) {
+        boolean[][] visited = new boolean[607][607];
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0});
+        int steps = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                if (removed[0] == x && removed[1] == y) {
+                    return steps;
+                }
+                for (int[] move : MOVES) {
+                    int newX = removed[0] + move[0];
+                    int newY = removed[1] + move[1];
+                    if (!visited[newX + 302][newY + 302]) {
+                        visited[newX + 302][newY + 302] = true;
+                        queue.add(new int[]{newX, newY});
+                    }
+                }
+            }
+            steps++;
         }
-        for (int[] dir : DIRS) {
-          int newX = removed[0] + dir[0];
-          int newY = removed[1] + dir[1];
-          if (visited[newX + 302][newY + 302]) {
-            continue;
-          }
-          visited[newX + 302][newY + 302] = true;
-          queue.add(new int[]{newX, newY});
-        }
-      }
-      numOfSteps++;
+        return steps;
     }
-    return numOfSteps;
-  }
 }

From 9d417554f8b3db6c721f4f9ee5e4c2e9f3d4055a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 23 May 2024 07:41:33 -0700
Subject: [PATCH 1995/2175] Create The Number of Beautiful Subsets.java

---
 Medium/The Number of Beautiful Subsets.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/The Number of Beautiful Subsets.java

diff --git a/Medium/The Number of Beautiful Subsets.java b/Medium/The Number of Beautiful Subsets.java
new file mode 100644
index 00000000..7057a18d
--- /dev/null
+++ b/Medium/The Number of Beautiful Subsets.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int beautifulSubsets(int[] nums, int k) {
+        Map<Integer, Integer> freqMap = new HashMap<>();
+        Arrays.sort(nums);
+        return countBeautifulSubsets(nums, k, freqMap, 0) - 1;
+    }
+
+    private int countBeautifulSubsets(int[] nums, int k, Map<Integer, Integer> freqMap, int idx) {
+        if (idx == nums.length) {
+            return 1;
+        }
+        int count = countBeautifulSubsets(nums, k, freqMap, idx + 1);
+        if (freqMap.getOrDefault(nums[idx] - k, 0) == 0) {
+            freqMap.put(nums[idx], freqMap.getOrDefault(nums[idx], 0) + 1);
+            count += countBeautifulSubsets(nums, k, freqMap, idx + 1);
+            freqMap.put(nums[idx], freqMap.getOrDefault(nums[idx], 0) - 1);
+        }
+        return count;
+    }
+}

From 447d746712a16287560af23e523a2641ac847f5e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 29 May 2024 07:17:12 -0700
Subject: [PATCH 1996/2175] Create Number of Steps to Reduce a Number in Binary
 Representation to One.java

---
 ...umber in Binary Representation to One.java | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Number of Steps to Reduce a Number in Binary Representation to One.java

diff --git a/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java b/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java
new file mode 100644
index 00000000..00a8296a
--- /dev/null
+++ b/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int numSteps(String s) {
+        int operations = 0;
+        StringBuilder sb = new StringBuilder(s);
+        while (sb.length() > 1) {
+            int n = sb.length();
+            if (sb.charAt(n - 1) == '0') {
+                // divide by 2
+                sb.deleteCharAt(n - 1);
+            } else {
+                // add 1 
+                int idx = n - 1;
+                while (idx >= 0 && sb.charAt(idx) != '0') {
+                    sb.setCharAt(idx, '0');
+                    idx--;
+                }
+                if (idx < 0) {
+                    sb.insert(0, '1');
+                } else {
+                    sb.setCharAt(idx, '1');
+                }
+            }
+            operations++;
+        }
+        return operations;
+    }
+}

From f967067bddf85a35522c0246e0a85386d0514cb8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 29 May 2024 07:20:42 -0700
Subject: [PATCH 1997/2175] Create Find the Number of Good Pairs I.java

---
 Easy/Find the Number of Good Pairs I.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Find the Number of Good Pairs I.java

diff --git a/Easy/Find the Number of Good Pairs I.java b/Easy/Find the Number of Good Pairs I.java
new file mode 100644
index 00000000..143d6abd
--- /dev/null
+++ b/Easy/Find the Number of Good Pairs I.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int numberOfPairs(int[] nums1, int[] nums2, int k) {
+        int count = 0;
+        for (int i = 0; i < nums1.length; i++) {
+            for (int j = 0; j < nums2.length; j++) {
+                if (nums1[i] % (nums2[j] * k) == 0) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+}

From 010f42b1f2319b3f4f430b0377df571bf8998248 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 29 May 2024 07:22:58 -0700
Subject: [PATCH 1998/2175] Create Find the XOR of Numbers Which Appear
 Twice.java

---
 Easy/Find the XOR of Numbers Which Appear Twice.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Find the XOR of Numbers Which Appear Twice.java

diff --git a/Easy/Find the XOR of Numbers Which Appear Twice.java b/Easy/Find the XOR of Numbers Which Appear Twice.java
new file mode 100644
index 00000000..baa845bc
--- /dev/null
+++ b/Easy/Find the XOR of Numbers Which Appear Twice.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public int duplicateNumbersXOR(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        int xor = 0;
+        for (int num : nums) {
+            if (!set.add(num)) {
+                xor = xor ^ num;
+            }
+        }
+        return xor;
+    }
+}

From b4ddaff710706d5bd1804fd0a5de1ad1f7d36008 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 1 Jun 2024 07:30:52 -0700
Subject: [PATCH 1999/2175] Create Longest Common Subsequence Between Sorted
 Arrays.java

---
 ... Common Subsequence Between Sorted Arrays.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Longest Common Subsequence Between Sorted Arrays.java

diff --git a/Medium/Longest Common Subsequence Between Sorted Arrays.java b/Medium/Longest Common Subsequence Between Sorted Arrays.java
new file mode 100644
index 00000000..d050d3fd
--- /dev/null
+++ b/Medium/Longest Common Subsequence Between Sorted Arrays.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public List<Integer> longestCommonSubsequence(int[][] arrays) {
+        List<Integer> result = new ArrayList<>();
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int[] arr : arrays) {
+            for (int num : arr) {
+                map.put(num, map.getOrDefault(num, 0) + 1);
+                if (map.get(num) == arrays.length) {
+                    result.add(num);
+                }
+            }
+        }
+        return result;
+    }
+}

From 210a81b9ad3d8a5ebb84ce6b546845641389dfe9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 2 Jun 2024 07:31:09 -0700
Subject: [PATCH 2000/2175] Create Minimum Number of Chairs in a Waiting
 Room.java

---
 Easy/Minimum Number of Chairs in a Waiting Room.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Minimum Number of Chairs in a Waiting Room.java

diff --git a/Easy/Minimum Number of Chairs in a Waiting Room.java b/Easy/Minimum Number of Chairs in a Waiting Room.java
new file mode 100644
index 00000000..d7db8060
--- /dev/null
+++ b/Easy/Minimum Number of Chairs in a Waiting Room.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int minimumChairs(String s) {
+        int requiredChairCount = 0;
+        int currChairCount = 0;
+        for (char c : s.toCharArray()) {
+            currChairCount += c == 'E' ? 1 : -1;
+            requiredChairCount = Math.max(requiredChairCount, currChairCount);
+        }
+        return requiredChairCount;
+    }
+}

From 4b1a03b1fdf1cb4b387ee4ff9b60d649971e3ab2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 6 Jun 2024 07:16:35 -0700
Subject: [PATCH 2001/2175] Update Hand of Straights.java

---
 Medium/Hand of Straights.java | 53 ++++++++++++++++++-----------------
 1 file changed, 28 insertions(+), 25 deletions(-)

diff --git a/Medium/Hand of Straights.java b/Medium/Hand of Straights.java
index ceff444a..5f407cf0 100644
--- a/Medium/Hand of Straights.java	
+++ b/Medium/Hand of Straights.java	
@@ -1,29 +1,32 @@
 class Solution {
-  public boolean isNStraightHand(int[] hand, int W) {
-    if (hand.length % W != 0) {
-      return false;
-    }
-    Map<Integer, Integer> counterMap = new HashMap<>();
-    Set<Integer> set = new TreeSet<>();
-    for (int num : hand) {
-      counterMap.put(num, counterMap.getOrDefault(num, 0) + 1);
-      set.add(num);
-    }
-    Iterator<Integer> iter = set.iterator();
-    Integer curr = iter.next();
-    while (counterMap.get(curr) > 0) {
-      int temp = curr;
-      for (int i = 0; i < W; i++) {
-        if (counterMap.getOrDefault(temp, 0) == 0) {
-          return false;
+    public boolean isNStraightHand(int[] hand, int groupSize) {
+        if (hand.length % groupSize != 0) {
+            return false;
+        }
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : hand) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>(map.keySet());
+        while (!pq.isEmpty()) {
+            List<Integer> temp = new ArrayList<>();
+            int prev = -1;
+            for (int i = 0; i < groupSize; i++) {
+                if (pq.isEmpty()) {
+                    return false;
+                }
+                int removed = pq.remove();
+                map.put(removed, map.get(removed) - 1);
+                if (map.get(removed) > 0) {
+                    temp.add(removed);
+                }
+                if (prev != -1 && removed != prev + 1) {
+                    return false;
+                }
+                prev = removed;
+            }
+            pq.addAll(temp);
         }
-        counterMap.put(temp, counterMap.get(temp) - 1);
-        temp++;
-      }
-      while (iter.hasNext() && counterMap.get(curr) == 0) {
-        curr = iter.next();
-      }
+        return true;
     }
-    return true;
-  }
 }

From b8a29e6a085598af7c6d2190d18ca55a6cf29b74 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Jun 2024 09:45:41 -0700
Subject: [PATCH 2002/2175] Create Substrings That Begin and End With the Same
 Letter.java

---
 ...ings That Begin and End With the Same Letter.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Medium/Substrings That Begin and End With the Same Letter.java

diff --git a/Medium/Substrings That Begin and End With the Same Letter.java b/Medium/Substrings That Begin and End With the Same Letter.java
new file mode 100644
index 00000000..62c93389
--- /dev/null
+++ b/Medium/Substrings That Begin and End With the Same Letter.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public long numberOfSubstrings(String s) {
+        int n = s.length();
+        long result = 0;
+        long[] prefixCount = new long[26];
+        for (int i = 0; i < n; i++) {
+            prefixCount[s.charAt(i) - 'a']++;
+            result += prefixCount[s.charAt(i) - 'a'];
+        }
+        return result;
+    }
+}

From 91e35a8936aa0ff52ad594953550c2d52bf51edd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Jun 2024 09:50:21 -0700
Subject: [PATCH 2003/2175] Create Clear Digits.java

---
 Easy/Clear Digits.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Clear Digits.java

diff --git a/Easy/Clear Digits.java b/Easy/Clear Digits.java
new file mode 100644
index 00000000..1d308863
--- /dev/null
+++ b/Easy/Clear Digits.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public String clearDigits(String s) {
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (Character.isDigit(c)) {
+                if (!sb.isEmpty()) {
+                    sb.deleteCharAt(sb.length() - 1);
+                }
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+}

From 55d0ecf0bbc7bdd6ce5f35d61f761718679a9f0f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Jun 2024 09:54:37 -0700
Subject: [PATCH 2004/2175] Create Find the Child Who Has the Ball After K
 Seconds.java

---
 Easy/Find the Child Who Has the Ball After K Seconds.java | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Easy/Find the Child Who Has the Ball After K Seconds.java

diff --git a/Easy/Find the Child Who Has the Ball After K Seconds.java b/Easy/Find the Child Who Has the Ball After K Seconds.java
new file mode 100644
index 00000000..6a4c8193
--- /dev/null
+++ b/Easy/Find the Child Who Has the Ball After K Seconds.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int numberOfChild(int n, int k) {
+        int factor = k / (n - 1);
+        int remainder = k % (n - 1);
+        return factor % 2 == 0 ? remainder : n - 1 - remainder;
+    }
+}

From 1cebeb3b089d01a796ed508a225ebdc7622d6a6f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Jun 2024 06:58:16 -0700
Subject: [PATCH 2005/2175] Create Find the N-th Value After K Seconds.java

---
 Medium/Find the N-th Value After K Seconds.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Find the N-th Value After K Seconds.java

diff --git a/Medium/Find the N-th Value After K Seconds.java b/Medium/Find the N-th Value After K Seconds.java
new file mode 100644
index 00000000..e457d0eb
--- /dev/null
+++ b/Medium/Find the N-th Value After K Seconds.java	
@@ -0,0 +1,15 @@
+class Solution {
+
+    private final int MOD = 1000_000_007;
+
+    public int valueAfterKSeconds(int n, int k) {
+        int[] arr = new int[n];
+        Arrays.fill(arr, 1);
+        while (k-- > 0) {
+            for (int i = 1; i < n; i++) {
+                arr[i] = (arr[i] + arr[i - 1]) % MOD;
+            }
+        }
+        return arr[n - 1];
+    }
+}

From 27aee486fa9a7ff0ca0cd9ff340e2c01e4bd1837 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Jun 2024 07:05:31 -0700
Subject: [PATCH 2006/2175] Create Find The First Player to win K Games in a
 Row.java

---
 ... First Player to win K Games in a Row.java | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Find The First Player to win K Games in a Row.java

diff --git a/Medium/Find The First Player to win K Games in a Row.java b/Medium/Find The First Player to win K Games in a Row.java
new file mode 100644
index 00000000..fe26c684
--- /dev/null
+++ b/Medium/Find The First Player to win K Games in a Row.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int findWinningPlayer(int[] skills, int k) {
+        Map<Integer, Integer> indexMap = new HashMap<>();
+        for (int i = 0; i < skills.length; i++) {
+            indexMap.put(skills[i], i);
+        }
+        Map<Integer, Integer> winCountMap = new HashMap<>();
+        Deque<Integer> deque = new ArrayDeque<>();
+        for (int num : skills) {
+            deque.addFirst(num);
+        }
+        while (deque.size() > 1) {
+            int first = deque.pollLast();
+            int second = deque.pollLast();
+            int winner = Math.max(first, second);
+            winCountMap.put(winner, winCountMap.getOrDefault(winner, 0) + 1);
+            deque.addLast(winner);
+            if (winCountMap.get(winner) == k) {
+                return indexMap.get(winner);
+            }
+        }
+        return indexMap.get(deque.poll());
+    }
+}

From fd3899c2bb07e8518e8d2113f0fbe4439cc9efdd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 14 Jun 2024 08:42:34 -0700
Subject: [PATCH 2007/2175] Create Minimum Increment to Make Array Unique.java

---
 Medium/Minimum Increment to Make Array Unique.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Minimum Increment to Make Array Unique.java

diff --git a/Medium/Minimum Increment to Make Array Unique.java b/Medium/Minimum Increment to Make Array Unique.java
new file mode 100644
index 00000000..7be5a583
--- /dev/null
+++ b/Medium/Minimum Increment to Make Array Unique.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int minIncrementForUnique(int[] nums) {
+        Arrays.sort(nums);
+        int increments = 0;
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] <= nums[i - 1]) {
+                increments += nums[i - 1] + 1 - nums[i];
+                nums[i] = nums[i - 1] + 1;
+            }
+        }
+        return increments;
+    }
+}

From a47c0009db592d3f446566f53352857df356918f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 15 Jun 2024 17:26:31 -0700
Subject: [PATCH 2008/2175] Create Patching Array.java

---
 Hard/Patching Array.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Hard/Patching Array.java

diff --git a/Hard/Patching Array.java b/Hard/Patching Array.java
new file mode 100644
index 00000000..6bf2a8ed
--- /dev/null
+++ b/Hard/Patching Array.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int minPatches(int[] nums, int n) {
+        int patches = 0;
+        long miss = 1;
+        int idx = 0;
+        while (miss <= n) {
+            if (idx < nums.length && nums[idx] <= miss) {
+                miss += nums[idx++];
+            } else {
+                miss += miss;
+                patches++;
+            }
+        }
+        return patches;
+    }
+}

From 31a4de9251647d7d234fb336337751dd7152282b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 16 Jun 2024 07:30:21 -0700
Subject: [PATCH 2009/2175] Create Count Pairs That Form a Complete Day I.java

---
 Easy/Count Pairs That Form a Complete Day I.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Count Pairs That Form a Complete Day I.java

diff --git a/Easy/Count Pairs That Form a Complete Day I.java b/Easy/Count Pairs That Form a Complete Day I.java
new file mode 100644
index 00000000..785a5937
--- /dev/null
+++ b/Easy/Count Pairs That Form a Complete Day I.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int countCompleteDayPairs(int[] hours) {
+        int count = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int hour : hours) {
+            count += map.getOrDefault((24 - hour % 24) % 24, 0);
+            map.put(hour % 24, map.getOrDefault(hour % 24, 0) + 1);
+        }
+        return count;
+    }
+}

From 33be1b9c03a87638dd9b6e377216ff771e5f915c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 17 Jun 2024 06:33:01 -0700
Subject: [PATCH 2010/2175] Update and rename Sum of Square Numbers.java to Sum
 of Square Numbers.java

---
 Easy/Sum of Square Numbers.java   | 17 -----------------
 Medium/Sum of Square Numbers.java | 18 ++++++++++++++++++
 2 files changed, 18 insertions(+), 17 deletions(-)
 delete mode 100644 Easy/Sum of Square Numbers.java
 create mode 100644 Medium/Sum of Square Numbers.java

diff --git a/Easy/Sum of Square Numbers.java b/Easy/Sum of Square Numbers.java
deleted file mode 100644
index 61e26dde..00000000
--- a/Easy/Sum of Square Numbers.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-  public boolean judgeSquareSum(int c) {
-    int left = 0;
-    int right = (int) Math.sqrt(c);
-    while (left <= right) {
-      int currSquareSum = left * left + right * right;
-      if (currSquareSum < c) {
-        left++;
-      } else if (currSquareSum > c) {
-        right--;
-      } else {
-        return true;
-      }
-    }
-    return false;
-  }
-}
diff --git a/Medium/Sum of Square Numbers.java b/Medium/Sum of Square Numbers.java
new file mode 100644
index 00000000..13f138c2
--- /dev/null
+++ b/Medium/Sum of Square Numbers.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean judgeSquareSum(int c) {
+        long left = 0;
+        long right = (long) Math.sqrt(c);
+        while (left <= right) {
+            long sum = left * left + right * right;
+            if (sum == c) {
+                return true;
+            }
+            if (sum > c) {
+                right--;
+            } else {
+                left++;
+            }
+        }
+        return false;
+    }
+}

From afa6897e96bfbbdb962b93586795c73bee61c0ec Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 19 Jun 2024 13:30:47 -0700
Subject: [PATCH 2011/2175] Create Minimum Number of Days to Make m
 Bouquets.java

---
 ...mum Number of Days to Make m Bouquets.java | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 Medium/Minimum Number of Days to Make m Bouquets.java

diff --git a/Medium/Minimum Number of Days to Make m Bouquets.java b/Medium/Minimum Number of Days to Make m Bouquets.java
new file mode 100644
index 00000000..83578712
--- /dev/null
+++ b/Medium/Minimum Number of Days to Make m Bouquets.java	
@@ -0,0 +1,37 @@
+class Solution {
+    public int minDays(int[] bloomDay, int m, int k) {
+        int left = 0;
+        int right = 0;
+        for (int day : bloomDay) {
+            right = Math.max(right, day);
+        }
+        int days = -1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (numberOfBouquet(bloomDay, mid, k) >= m) {
+                days = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return days;
+    }
+
+    private int numberOfBouquet(int[] bloomDay, int mid, int k) {
+        int bouquetCount = 0;
+        int count = 0;
+        for (int i = 0; i < bloomDay.length; i++) {
+            if (bloomDay[i] <= mid) {
+                count++;
+            } else {
+                count = 0;
+            }
+            if (count == k) {
+                bouquetCount++;
+                count = 0;
+            }
+        }
+        return bouquetCount;
+    }
+}

From 865f81f10f77b149e5e6619ef81884ff8f4b8834 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 20 Jun 2024 14:07:47 -0700
Subject: [PATCH 2012/2175] Create Magnetic Force Between Two Balls.java

---
 Medium/Magnetic Force Between Two Balls.java | 32 ++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Magnetic Force Between Two Balls.java

diff --git a/Medium/Magnetic Force Between Two Balls.java b/Medium/Magnetic Force Between Two Balls.java
new file mode 100644
index 00000000..9ca9708b
--- /dev/null
+++ b/Medium/Magnetic Force Between Two Balls.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public int maxDistance(int[] position, int m) {
+        int result = 0;
+        int n = position.length;
+        Arrays.sort(position);
+        int left = 1;
+        int right = (int) Math.ceil(position[n - 1] / (m - 1.0));
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (isPossible(position, mid, m)) {
+                result = mid;
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return result;
+    }
+
+    private boolean isPossible(int[] position, int distance, int m) {
+        int prevBall = position[0];
+        int ballCount = 1;
+        for (int i = 1; i < position.length && ballCount < m; i++) {
+            int curr = position[i];
+            if (curr - prevBall >= distance) {
+                ballCount++;
+                prevBall = curr;
+            }
+        }
+        return ballCount == m;
+    }
+}

From 397b6b81b5f0cf0f9809e9b72e969743f81e7ab5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Jun 2024 08:48:10 -0700
Subject: [PATCH 2013/2175] Create Count Number of Nice Subarrays.java

---
 Medium/Count Number of Nice Subarrays.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Count Number of Nice Subarrays.java

diff --git a/Medium/Count Number of Nice Subarrays.java b/Medium/Count Number of Nice Subarrays.java
new file mode 100644
index 00000000..e2648bd3
--- /dev/null
+++ b/Medium/Count Number of Nice Subarrays.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int numberOfSubarrays(int[] nums, int k) {
+        int sum = 0;
+        int count = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(sum, 1);
+        for (int i = 0; i < nums.length; i++) {
+            sum += nums[i] % 2;
+            count += map.getOrDefault(sum - k, 0);
+            map.put(sum, map.getOrDefault(sum, 0) + 1);
+        }
+        return count;
+    }
+}

From 2c963723a148f3d328299c9aa14263a243ba20ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Jun 2024 10:49:45 -0700
Subject: [PATCH 2014/2175] Create Find Minimum Operations to Make All Elements
 Divisible by Three.java

---
 ...tions to Make All Elements Divisible by Three.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Find Minimum Operations to Make All Elements Divisible by Three.java

diff --git a/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java b/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java
new file mode 100644
index 00000000..c8d6f59e
--- /dev/null
+++ b/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int minimumOperations(int[] nums) {
+        int count = 0;
+        for (int num : nums) {
+            if (num % 3 != 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

From d5206efa86285870633ce24b787c615174e262bc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Jun 2024 10:59:45 -0700
Subject: [PATCH 2015/2175] Create Count Substrings Without Repeating
 Character.java

---
 ...ubstrings Without Repeating Character.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Count Substrings Without Repeating Character.java

diff --git a/Medium/Count Substrings Without Repeating Character.java b/Medium/Count Substrings Without Repeating Character.java
new file mode 100644
index 00000000..6ffcf7cd
--- /dev/null
+++ b/Medium/Count Substrings Without Repeating Character.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int numberOfSpecialSubstrings(String s) {
+        int start = 0;
+        int end = 0;
+        int n = s.length();
+        int result = 0;
+        Map<Character, Integer> map = new HashMap<>();
+        while (end < n) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            while (start < end && map.get(s.charAt(end)) > 1) {
+                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
+                start++;
+            }
+            end++;
+            result += end - start;
+        }
+        return result;
+    }
+}

From 1063dfd5b34ccff45628bd431e23aa294b43ff40 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 24 Jun 2024 07:46:06 -0700
Subject: [PATCH 2016/2175] Create Minimum Average of Smallest and Largest
 Elements.java

---
 ... Average of Smallest and Largest Elements.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Easy/Minimum Average of Smallest and Largest Elements.java

diff --git a/Easy/Minimum Average of Smallest and Largest Elements.java b/Easy/Minimum Average of Smallest and Largest Elements.java
new file mode 100644
index 00000000..f1fd9e2d
--- /dev/null
+++ b/Easy/Minimum Average of Smallest and Largest Elements.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public double minimumAverage(int[] nums) {
+        double minAverage = Double.MAX_VALUE;
+        Arrays.sort(nums);
+        int left = 0;
+        int right = nums.length - 1;
+        while (left < right) {
+            double average = (nums[left] + nums[right]) / 2.0;
+            minAverage = Math.min(minAverage, average);
+            left++;
+            right--;
+        }
+        return minAverage;
+    }
+}

From 35ee9b003d7dd5e17a732680fd195e2a75fe2c37 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 25 Jun 2024 07:18:51 -0700
Subject: [PATCH 2017/2175] Create Find the Minimum Area to Cover All Ones
 I.java

---
 ... the Minimum Area to Cover All Ones I.java | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Find the Minimum Area to Cover All Ones I.java

diff --git a/Medium/Find the Minimum Area to Cover All Ones I.java b/Medium/Find the Minimum Area to Cover All Ones I.java
new file mode 100644
index 00000000..538bf894
--- /dev/null
+++ b/Medium/Find the Minimum Area to Cover All Ones I.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int minimumArea(int[][] grid) {
+        int minRow = Integer.MAX_VALUE;
+        int minCol = Integer.MAX_VALUE;
+        int maxRow = Integer.MIN_VALUE;
+        int maxCol = Integer.MIN_VALUE;
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1) {
+                    minRow = Math.min(minRow, i);
+                    minCol = Math.min(minCol, j);
+                    maxRow = Math.max(maxRow, i);
+                    maxCol = Math.max(maxCol, j);
+                }
+            }
+        }
+        if (minRow == Integer.MAX_VALUE) {
+            return 0;
+        }
+        int length = maxRow - minRow + 1;
+        int breadth = maxCol - minCol + 1;
+        return length * breadth;
+    }
+}

From acfa4c155ad1e7a95a28695f1d142b6fe80fbd7d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 25 Jun 2024 18:09:27 -0700
Subject: [PATCH 2018/2175] Update Balance a Binary Search Tree.java

---
 Medium/Balance a Binary Search Tree.java | 54 ++++++++++++++----------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/Medium/Balance a Binary Search Tree.java b/Medium/Balance a Binary Search Tree.java
index 9fbf14ce..dd07996e 100644
--- a/Medium/Balance a Binary Search Tree.java	
+++ b/Medium/Balance a Binary Search Tree.java	
@@ -14,29 +14,37 @@
  * }
  */
 class Solution {
-  public TreeNode balanceBST(TreeNode root) {
-    List<Integer> sortedList = new ArrayList<>();
-    inorderTraversal(root, sortedList);
-    return buildBST(sortedList, 0, sortedList.size() - 1);
-  }   
-  
-  private TreeNode buildBST(List<Integer> sortedList, int start, int end) {
-    if (start > end) {
-      return null;
+    public TreeNode balanceBST(TreeNode root) {
+        List<Integer> inorder = getInorderNodes(root);
+        return createBST(inorder, 0, inorder.size() - 1);
     }
-    int mid = (start + end) / 2;
-    TreeNode root = new TreeNode(sortedList.get(mid));
-    root.left = buildBST(sortedList, start, mid - 1);
-    root.right = buildBST(sortedList, mid + 1, end);
-    return root;
-  }
-  
-  private void inorderTraversal(TreeNode root, List<Integer> sortedList) {
-    if (root == null) {
-      return;
+
+    private List<Integer> getInorderNodes(TreeNode root) {
+        Stack<TreeNode> stack = new Stack<>();
+        while (root != null) {
+            stack.push(root);
+            root = root.left;
+        }
+        List<Integer> list = new ArrayList<>();
+        while (!stack.isEmpty()) {
+            TreeNode node = stack.pop();
+            list.add(node.val);
+            TreeNode rightNode = node.right;
+            while (rightNode != null) {
+                stack.push(rightNode);
+                rightNode = rightNode.left;
+            }
+        }
+        return list;
+    }
+
+    private TreeNode createBST(List<Integer> list, int start, int end) {
+        if (start > end) {
+            return null;
+        }
+        int mid = (start + end) / 2;
+        TreeNode leftTree = createBST(list, start, mid - 1);
+        TreeNode rightTree = createBST(list, mid + 1, end);
+        return new TreeNode(list.get(mid), leftTree, rightTree);
     }
-    inorderTraversal(root.left, sortedList);
-    sortedList.add(root.val);
-    inorderTraversal(root.right, sortedList);
-  }
 }

From a116f9b3c5fa4477a54e5ebef4531f46ddfecdd5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 26 Jun 2024 07:21:54 -0700
Subject: [PATCH 2019/2175] Create Minimum Operations to Make Binary Array
 Elements Equal to One I.java

---
 ... Binary Array Elements Equal to One I.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java

diff --git a/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java b/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java
new file mode 100644
index 00000000..4b5b20a1
--- /dev/null
+++ b/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int minOperations(int[] nums) {
+        int count = 0;
+        for (int i = 0; i <= nums.length - 3; i++) {
+            if (nums[i] == 0) {
+                nums[i] = nums[i] == 0 ? 1 : 0;
+                nums[i + 1] = nums[i + 1] == 0 ? 1 : 0;
+                nums[i + 2] = nums[i + 2] == 0 ? 1 : 0;
+                count++;
+            }
+        }
+        for (int i = nums.length - 3; i < nums.length; i++) {
+            if (nums[i] == 0) {
+                return -1;
+            } 
+        }
+        return count;
+    }
+}

From f981b3283fbd6a9bd483a813cd1c502c3e27de67 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 27 Jun 2024 06:32:40 -0700
Subject: [PATCH 2020/2175] Update Find Center of Star Graph.java

---
 Medium/Find Center of Star Graph.java | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/Medium/Find Center of Star Graph.java b/Medium/Find Center of Star Graph.java
index f3f6de5a..8270ad2d 100644
--- a/Medium/Find Center of Star Graph.java	
+++ b/Medium/Find Center of Star Graph.java	
@@ -1,13 +1,16 @@
-import java.util.Map.Entry;
-
 class Solution {
-  public int findCenter(int[][] edges) {
-    Map<Integer, Set<Integer>> map = new HashMap<>();
-    for (int[] edge : edges) {
-      map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
-      map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    public int findCenter(int[][] edges) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int n = edges.length;
+        for (int[] edge : edges) {
+            map.put(edge[0], map.getOrDefault(edge[0], 0) + 1);
+            map.put(edge[1], map.getOrDefault(edge[1], 0) + 1);
+        }
+        for (Integer key : map.keySet()) {
+            if (map.get(key) == n) {
+                return key;
+            }
+        }
+        return -1;
     }
-    return map.entrySet().stream().filter(entry -> entry.getValue().size() == edges.length).map(
-        Entry::getKey).findFirst().orElse(-1);
-  }
 }

From 41b043a398434deca08dd2d99c179d1fc1c2a3a9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 29 Jun 2024 12:53:22 -0700
Subject: [PATCH 2021/2175] Update All Ancestors of a Node in a Directed
 Acyclic Graph.java

---
 ...of a Node in a Directed Acyclic Graph.java | 54 +++++++++++--------
 1 file changed, 32 insertions(+), 22 deletions(-)

diff --git a/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java b/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java
index 60ab5900..36063815 100644
--- a/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java	
+++ b/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java	
@@ -1,26 +1,36 @@
 class Solution {
-  public List<List<Integer>> getAncestors(int n, int[][] edges) {
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    for (int[] edge : edges) {
-      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
-    }
-    List<List<Integer>> result = new ArrayList<>();
-    for (int i = 0; i < n; i++) {
-      List<Integer> ancestors = new ArrayList<>();
-      Set<Integer> visited = new HashSet<>();
-      Queue<Integer> queue = new LinkedList<>(graph.getOrDefault(i, new ArrayList<>()));
-      while (!queue.isEmpty()) {
-        int removed = queue.remove();
-        if (visited.contains(removed)) {
-          continue;
+    public List<List<Integer>> getAncestors(int n, int[][] edges) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        int[] indegree = new int[n];
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            indegree[edge[1]]++;
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        Map<Integer, Set<Integer>> ancestors = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                queue.offer(i);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int node = queue.poll();
+            ancestors.computeIfAbsent(node, k -> new HashSet<>());
+            for (int dependents : graph.getOrDefault(node, Collections.emptyList())) {
+                ancestors.computeIfAbsent(dependents, k -> new HashSet<>()).add(node);
+                ancestors.get(dependents).addAll(ancestors.get(node));
+                indegree[dependents]--;
+                if (indegree[dependents] == 0) {
+                    queue.offer(dependents);
+                }
+            }
+        }
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            List<Integer> currNodeAncestors = new ArrayList<>(ancestors.getOrDefault(i, Collections.emptySet()));
+            currNodeAncestors.sort(Comparator.naturalOrder());
+            result.add(currNodeAncestors);
         }
-        ancestors.add(removed);
-        visited.add(removed);
-        queue.addAll(graph.getOrDefault(removed, new ArrayList<>()));
-      }
-      Collections.sort(ancestors);
-      result.add(ancestors);
+        return result;
     }
-    return result;
-  }
 }

From 60879733e7648f86e0b1fbc071ad7f72ea520c35 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 1 Jul 2024 07:21:18 -0700
Subject: [PATCH 2022/2175] Update The Earliest Moment When Everyone Become
 Friends.java

---
 ...t Moment When Everyone Become Friends.java | 78 ++++++++-----------
 1 file changed, 33 insertions(+), 45 deletions(-)

diff --git a/Medium/The Earliest Moment When Everyone Become Friends.java b/Medium/The Earliest Moment When Everyone Become Friends.java
index 578a04cb..8de3e818 100644
--- a/Medium/The Earliest Moment When Everyone Become Friends.java	
+++ b/Medium/The Earliest Moment When Everyone Become Friends.java	
@@ -1,54 +1,42 @@
 class Solution {
-  public int earliestAcq(int[][] logs, int n) {
-    Arrays.sort(logs, Comparator.comparingInt(o -> o[0]));
-    DisjointSet disjointSet = new DisjointSet(n);
-    for (int[] log : logs) {
-      disjointSet.union(log[1], log[2]);
-      if (disjointSet.unionCount == 1) {
-        return log[0];
-      }
+    public int earliestAcq(int[][] logs, int n) {
+        Arrays.sort(logs, Comparator.comparingInt(a -> a[0]));
+        UnionFind uf = new UnionFind(n);
+        for (int[] log : logs) {
+            uf.union(log[1], log[2]);
+            if (uf.count == 1) {
+                return log[0];
+            }
+        }
+        return -1;
     }
-    return -1;
-  }
-
-  private static final class DisjointSet {
 
-    private final int[] root;
-    private final int[] rank;
-    public int unionCount;
-
-    public DisjointSet(int size) {
-      this.root = new int[size];
-      this.rank = new int[size];
-      for (int i = 0; i < size; i++) {
-        this.root[i] = i;
-        this.rank[i] = 1;
-      }
-      this.unionCount = size;
-    }
+    static class UnionFind {
+        private final int[] parent;
+        private int count;
 
-    public void union(int nodeOne, int nodeTwo) {
-      int rootOne = find(nodeOne);
-      int rootTwo = find(nodeTwo);
-      if (rootOne != rootTwo) {
-        if (this.rank[rootOne] > this.rank[rootTwo]) {
-          this.root[rootTwo] = rootOne;
-        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
-          this.root[rootOne] = rootTwo;
-        } else {
-          this.root[rootTwo] = rootOne;
-          this.rank[rootOne]++;
+        public UnionFind(int n) {
+            parent = new int[n];
+            count = n;
+            for (int i = 0; i < n; i++) {
+                parent[i] = i;
+            }
         }
-        this.unionCount--;
-      }
-    }
 
+        public int find(int node) {
+            if (parent[node] != node) {
+                parent[node] = find(parent[node]);
+            }
+            return parent[node];
+        }
 
-    public int find(int node) {
-      if (node == root[node]) {
-        return node;
-      }
-      return root[node] = find(root[node]);
+        public void union(int x, int y) {
+            int rootX = find(x);
+            int rootY = find(y);
+            if (rootX != rootY) {
+                parent[rootX] = rootY;
+                count--;
+            }
+        }
     }
-  }
 }

From 568f9bad22717e799a2aa1b910df29b14f92f5a2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 3 Jul 2024 07:40:43 -0700
Subject: [PATCH 2023/2175] Create Minimum Difference Between Largest and
 Smallest Value in Three Moves.java

---
 ...argest and Smallest Value in Three Moves.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java

diff --git a/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java b/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java
new file mode 100644
index 00000000..2722191a
--- /dev/null
+++ b/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int minDifference(int[] nums) {
+        int n = nums.length;
+        if (n <= 4) {
+            return 0;
+        }
+        Arrays.sort(nums);
+        int minDiff = Integer.MAX_VALUE;
+        int left = 0;
+        int right = n - 4;
+        while (left < 4) {
+            minDiff = Math.min(minDiff, nums[right++] - nums[left++]);
+        }
+        return minDiff;
+    }
+}

From 86ad1a23993e937706f6572c2b10bc6ba012ee07 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 8 Jul 2024 13:39:33 -0700
Subject: [PATCH 2024/2175] Create Find the Winner of the Circular Game.java

---
 Medium/Find the Winner of the Circular Game.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Find the Winner of the Circular Game.java

diff --git a/Medium/Find the Winner of the Circular Game.java b/Medium/Find the Winner of the Circular Game.java
new file mode 100644
index 00000000..816b3aa4
--- /dev/null
+++ b/Medium/Find the Winner of the Circular Game.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int findTheWinner(int n, int k) {
+        Queue<Integer> circle = new LinkedList<>();
+        for (int i = 1; i <= n; i++) {
+            circle.add(i);
+        }
+        while (circle.size() > 1) {
+            for (int i = 0; i < k - 1; i++) {
+                circle.add(circle.remove());
+            }
+            circle.remove();
+        }
+        return circle.peek();
+    }
+}

From be7bd21bae156c80b5d304f095e4c1c7c3c1a9ba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 9 Jul 2024 16:31:31 -0700
Subject: [PATCH 2025/2175] Update Remove Duplicates From an Unsorted Linked
 List.java

---
 ...plicates From an Unsorted Linked List.java | 46 +++++++++----------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/Medium/Remove Duplicates From an Unsorted Linked List.java b/Medium/Remove Duplicates From an Unsorted Linked List.java
index e62d60c7..18308224 100644
--- a/Medium/Remove Duplicates From an Unsorted Linked List.java	
+++ b/Medium/Remove Duplicates From an Unsorted Linked List.java	
@@ -9,31 +9,29 @@
  * }
  */
 class Solution {
-  public ListNode deleteDuplicatesUnsorted(ListNode head) {
-    Map<Integer, Integer> map = new HashMap<>();
-    ListNode curr = head;
-    while (curr != null) {
-      map.put(curr.val, map.getOrDefault(curr.val, 0) + 1);
-      curr = curr.next;
-    }
-    curr = head;
-    ListNode newHead = null;
-    ListNode prev = null;
-    while (curr != null) {
-      if (map.get(curr.val) > 1) {
-        ListNode nextNode = curr.next;
-        if (prev != null) {
-          prev.next = nextNode;
+    public ListNode deleteDuplicatesUnsorted(ListNode head) {
+        Map<Integer, Integer> map = new HashMap<>();
+        ListNode curr = head;
+        while (curr != null) {
+            map.put(curr.val, map.getOrDefault(curr.val, 0) + 1);
+            curr = curr.next;
         }
-        curr = nextNode;
-      } else {
-        if (newHead == null) {
-          newHead = curr;
+        curr = head;
+        ListNode prev = null;
+        ListNode newHead = null;
+        while (curr != null) {
+            if (map.get(curr.val) > 1) {
+                if (prev != null) {
+                    prev.next = curr.next;
+                }
+            } else {
+                prev = curr;
+                if (newHead == null) {
+                    newHead = curr;
+                }
+            }
+            curr = curr.next;
         }
-        prev = curr;
-        curr = curr.next;
-      }
+        return newHead;
     }
-    return newHead;
-  }
 }

From 3625ba91340dcefb6ff2183a75d4c7e333dc7481 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 12 Jul 2024 06:50:40 -0700
Subject: [PATCH 2026/2175] Create Maximum Score From Removing Substrings.java

---
 ...aximum Score From Removing Substrings.java | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Medium/Maximum Score From Removing Substrings.java

diff --git a/Medium/Maximum Score From Removing Substrings.java b/Medium/Maximum Score From Removing Substrings.java
new file mode 100644
index 00000000..0f7ccf87
--- /dev/null
+++ b/Medium/Maximum Score From Removing Substrings.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int maximumGain(String s, int x, int y) {
+        int score = 0;
+        String firstPass = removeSubstring(s, x > y ? "ab" : "ba");
+        int removeCount = (s.length() - firstPass.length()) / 2;
+        score += removeCount * Math.max(x, y);
+        String secondPass = removeSubstring(firstPass, x > y ? "ba" : "ab");
+        removeCount = (firstPass.length() - secondPass.length()) / 2;
+        score += removeCount * Math.min(x, y);
+        return score;
+    }
+
+    private String removeSubstring(String s, String target) {
+        Stack<Character> stack = new Stack<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c == target.charAt(1) && !stack.isEmpty() && stack.peek() == target.charAt(0)) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
+    }
+}

From df3dac19974910cc81c4c737a0ee85245adf5685 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 13 Jul 2024 10:03:58 -0700
Subject: [PATCH 2027/2175] Create Robot Collisions.java

---
 Hard/Robot Collisions.java | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Hard/Robot Collisions.java

diff --git a/Hard/Robot Collisions.java b/Hard/Robot Collisions.java
new file mode 100644
index 00000000..4202122c
--- /dev/null
+++ b/Hard/Robot Collisions.java	
@@ -0,0 +1,38 @@
+class Solution {
+    public List<Integer> survivedRobotsHealths(int[] positions, int[] healths, String directions) {
+        int n = positions.length;
+        Integer[] indices = new Integer[n];
+        for (int i = 0; i < n; i++) {
+            indices[i] = i;
+        }
+        Arrays.sort(indices, (a, b) -> Integer.compare(positions[a], positions[b]));
+        Stack<Integer> stack = new Stack<>();
+        for (Integer index : indices) {
+            if (directions.charAt(index) == 'R') {
+                stack.push(index);
+            } else {
+                while (!stack.isEmpty() && healths[index] > 0) {
+                    int poppedIndex = stack.pop();
+                    if (healths[poppedIndex] > healths[index]) {
+                        healths[poppedIndex]--;
+                        healths[index] = 0;
+                        stack.push(poppedIndex);
+                    } else if (healths[poppedIndex] < healths[index]) {
+                        healths[index]--;
+                        healths[poppedIndex] = 0;
+                    } else {
+                        healths[poppedIndex] = 0;
+                        healths[index] = 0;
+                    }
+                }
+            }
+        }
+        List<Integer> result = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (healths[i] > 0) {
+                result.add(healths[i]);
+            }
+        }
+        return result;
+    }
+}

From 62f366439d3bdf7e63794356eb1c544a3b5afef4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 13 Jul 2024 17:34:13 -0700
Subject: [PATCH 2028/2175] Create Maximum Points After Enemy Battles.java

---
 Medium/Maximum Points After Enemy Battles.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Maximum Points After Enemy Battles.java

diff --git a/Medium/Maximum Points After Enemy Battles.java b/Medium/Maximum Points After Enemy Battles.java
new file mode 100644
index 00000000..2358cd8f
--- /dev/null
+++ b/Medium/Maximum Points After Enemy Battles.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public long maximumPoints(int[] enemyEnergies, int currentEnergy) {
+        long sum = 0;
+        int minimumEnergy = Integer.MAX_VALUE;
+        for (int energy : enemyEnergies) {
+            sum += energy;
+            minimumEnergy = Math.min(minimumEnergy, energy);
+        }
+        if (currentEnergy < minimumEnergy) {
+            return 0;
+        }
+        long totalEnergy = currentEnergy;
+        totalEnergy += sum - minimumEnergy;
+        return totalEnergy / minimumEnergy;
+    }
+}

From 57435b89c7cbca66b994cf2f3c05de888bf3c924 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 17 Jul 2024 07:12:38 -0700
Subject: [PATCH 2029/2175] Update Delete Nodes And Return Forest.java

---
 Medium/Delete Nodes And Return Forest.java | 53 +++++++++++-----------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/Medium/Delete Nodes And Return Forest.java b/Medium/Delete Nodes And Return Forest.java
index c3ec8f1b..344770b5 100644
--- a/Medium/Delete Nodes And Return Forest.java	
+++ b/Medium/Delete Nodes And Return Forest.java	
@@ -14,33 +14,34 @@
  * }
  */
 class Solution {
-  public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
-    List<TreeNode> result = new ArrayList<>();
-    Set<Integer> deleteSet = Arrays.stream(to_delete).boxed().collect(Collectors.toSet());
-    helper(root, deleteSet, result, null);
-    return result;
-  }
-  
-  private void helper(TreeNode node, Set<Integer> deleteSet, List<TreeNode> result, TreeNode parent) {
-    if (node == null) {
-      return;
+    public List<TreeNode> delNodes(TreeNode root, int[] toDelete) {
+        Set<Integer> set = new HashSet<>();
+        for (int val : toDelete) {
+            set.add(val);
+        }
+        List<TreeNode> result = new ArrayList<>();
+        recurse(root, result, set, null);
+        return result;
     }
-    TreeNode nextParent = null;
-    if (deleteSet.contains(node.val)) {
-      if (parent != null) {
-        if (parent.left == node) {
-          parent.left = null;
-        } else {
-          parent.right = null;
+
+    private void recurse(TreeNode root, List<TreeNode> result, Set<Integer> set, TreeNode parent) {
+        if (root == null) {
+            return;
+        }
+        if (set.contains(root.val)) {
+            if (parent != null && parent.left == root) {
+                parent.left = null;
+            } else if (parent != null && parent.right == root) {
+                parent.right = null;
+            }
+            recurse(root.left, result, set, null);
+            recurse(root.right, result, set, null);
+            return;
+        }
+        if (parent == null) {
+            result.add(root);
         }
-      }
-    } else {
-      if (parent == null) {
-        result.add(node); 
-      }
-      nextParent = node;
+        recurse(root.left, result, set, root);
+        recurse(root.right, result, set, root);
     }
-    helper(node.left, deleteSet, result, nextParent);
-    helper(node.right, deleteSet, result, nextParent);
-  }
 }

From e69114728912b48564c236b4744428d4aecccfb2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 22 Jul 2024 07:35:17 -0700
Subject: [PATCH 2030/2175] Create Number of Good Leaf Nodes Pairs.java

---
 Medium/Number of Good Leaf Nodes Pairs.java | 59 +++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 Medium/Number of Good Leaf Nodes Pairs.java

diff --git a/Medium/Number of Good Leaf Nodes Pairs.java b/Medium/Number of Good Leaf Nodes Pairs.java
new file mode 100644
index 00000000..c54d967f
--- /dev/null
+++ b/Medium/Number of Good Leaf Nodes Pairs.java	
@@ -0,0 +1,59 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int countPairs(TreeNode root, int distance) {
+        Map<TreeNode, List<TreeNode>> graph = new HashMap<>();
+        Set<TreeNode> leaves = new HashSet<>();
+        traverse(root, null, graph, leaves);
+        int result = 0;
+        for (TreeNode leaf : leaves) {
+            Queue<TreeNode> queue = new LinkedList<>();
+            Set<TreeNode> visited = new HashSet<>();
+            queue.add(leaf);
+            visited.add(leaf);
+            for (int i = 0; i <= distance; i++) {
+                int size = queue.size();
+                while (size-- > 0) {
+                    TreeNode curr = queue.remove();
+                    if (leaves.contains(curr) && curr != leaf) {
+                        result++;
+                    }
+                    for (TreeNode neighbor : graph.getOrDefault(curr, new ArrayList<>())) {
+                        if (visited.add(neighbor)) {
+                            queue.add(neighbor);
+                        }
+                    }
+                }
+            }
+        }
+        return result / 2;
+    }
+
+    private void traverse(TreeNode node, TreeNode parent, Map<TreeNode, List<TreeNode>> graph, Set<TreeNode> leaves) {
+        if (node == null) {
+            return;
+        }
+        if (node.left == null && node.right == null) {
+            leaves.add(node);
+        }
+        if (parent != null) {
+            graph.computeIfAbsent(parent, k -> new ArrayList<>()).add(node);
+            graph.computeIfAbsent(node, k -> new ArrayList<>()).add(parent);
+        }
+        traverse(node.left, node, graph, leaves);
+        traverse(node.right, node, graph, leaves);
+    }
+}

From 9800de288ad74098afb62b6eebe3ffa044f9604a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 28 Jul 2024 13:44:49 -0700
Subject: [PATCH 2031/2175] Create Find if Digit Game Can Be Won.java

---
 Easy/Find if Digit Game Can Be Won.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Find if Digit Game Can Be Won.java

diff --git a/Easy/Find if Digit Game Can Be Won.java b/Easy/Find if Digit Game Can Be Won.java
new file mode 100644
index 00000000..22c76892
--- /dev/null
+++ b/Easy/Find if Digit Game Can Be Won.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public boolean canAliceWin(int[] nums) {
+        int singleDigitSum = 0;
+        int doubleDigitSum = 0;
+        for (int num : nums) {
+            if (String.valueOf(num).length() > 1) {
+                doubleDigitSum += num;
+            } else {
+                singleDigitSum += num;
+            }
+        }
+        return singleDigitSum > doubleDigitSum || doubleDigitSum > singleDigitSum;
+    }
+}

From c977c77ff129b5957082b1134361538b9ef997d1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Aug 2024 09:43:37 -0700
Subject: [PATCH 2032/2175] Create Make Two Arrays Equal by Reversing
 Subarrays.java

---
 ...wo Arrays Equal by Reversing Subarrays.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Make Two Arrays Equal by Reversing Subarrays.java

diff --git a/Easy/Make Two Arrays Equal by Reversing Subarrays.java b/Easy/Make Two Arrays Equal by Reversing Subarrays.java
new file mode 100644
index 00000000..62ce7dca
--- /dev/null
+++ b/Easy/Make Two Arrays Equal by Reversing Subarrays.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean canBeEqual(int[] target, int[] arr) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : target) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        for (int num : arr) {
+            if (!map.containsKey(num)) {
+                return false;
+            }
+            map.put(num, map.get(num) - 1);
+            if (map.get(num) == 0) {
+                map.remove(num);
+            }
+        }
+        return map.isEmpty();
+    }
+}

From cf1d49ca0da00b6e50a10a2a0a440609a7d13601 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 3 Aug 2024 17:32:33 -0700
Subject: [PATCH 2033/2175] Update Range Sum of Sorted Subarray Sums.java

---
 Medium/Range Sum of Sorted Subarray Sums.java | 43 +++++++++----------
 1 file changed, 20 insertions(+), 23 deletions(-)

diff --git a/Medium/Range Sum of Sorted Subarray Sums.java b/Medium/Range Sum of Sorted Subarray Sums.java
index c8dad58b..9b7504b7 100644
--- a/Medium/Range Sum of Sorted Subarray Sums.java	
+++ b/Medium/Range Sum of Sorted Subarray Sums.java	
@@ -1,26 +1,23 @@
 class Solution {
-  final int MOD = 100000007;
-  public int rangeSum(int[] nums, int n, int left, int right) {
-    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
-      public int compare(int[] o1, int[] o2) {
-        return o1[0] - o2[0];
-      }
-    });
-    for (int i = 0; i < n; i++) {
-      pq.add(new int[]{nums[i], i + 1});
+    private static final int MOD = 1000_000_007;
+
+    public int rangeSum(int[] nums, int n, int left, int right) {
+        Queue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(o -> o[0]));
+        for (int i = 0; i < n; i++) {
+            pq.add(new int[]{nums[i], i + 1});
+        }
+        int sum = 0;
+        for (int i = 1; i <= right; i++) {
+            int[] removed = pq.poll();
+            if (i >= left) {
+                sum = (sum + removed[0]) % MOD;
+            }
+            if (removed[1] < n) {
+                removed[0] = removed[0] + nums[removed[1]];
+                removed[1]++;
+                pq.add(removed);
+            }
+        }
+        return sum;
     }
-    int sum = 0;
-    for (int i = 1; i <= right; i++) {
-      int[] removed = pq.poll();
-      if (i >= left) {
-        sum = (sum + removed[0]) % MOD;
-      }
-      if (removed[1] < n) {
-        removed[0] = removed[0] + nums[removed[1]];
-        removed[1]++;
-        pq.add(removed);
-      }
-    }
-    return sum;
-  }
 }

From b082bd05c66faa3219ce3252834d273131100a28 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 4 Aug 2024 11:14:17 -0700
Subject: [PATCH 2034/2175] Create Design Neighbor Sum Service.java

---
 Easy/Design Neighbor Sum Service.java | 50 +++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 Easy/Design Neighbor Sum Service.java

diff --git a/Easy/Design Neighbor Sum Service.java b/Easy/Design Neighbor Sum Service.java
new file mode 100644
index 00000000..93446e53
--- /dev/null
+++ b/Easy/Design Neighbor Sum Service.java	
@@ -0,0 +1,50 @@
+class neighborSum {
+
+    private static final int[][] ADJACENT_DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    private static final int[][] DIAGONAL_DIRS = {{1, -1}, {-1, 1}, {1, 1}, {-1, -1}};
+
+    private final int[][] grid;
+    private final int numRows;
+    private final int numCols;
+    private final Map<Integer, int[]> valueToCoordinateMap;
+
+    public neighborSum(int[][] grid) {
+        this.numRows = grid.length;
+        this.numCols = grid[0].length;
+        this.valueToCoordinateMap = new HashMap<>();
+        this.grid = new int[numRows][numCols];
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                this.grid[i][j] = grid[i][j];
+                this.valueToCoordinateMap.put(grid[i][j], new int[]{i, j});
+            }
+        }
+    }
+    
+    public int adjacentSum(int value) {
+        return calculateSum(valueToCoordinateMap.get(value), ADJACENT_DIRS);
+    }
+    
+    public int diagonalSum(int value) {
+        return calculateSum(valueToCoordinateMap.get(value), DIAGONAL_DIRS);
+    }
+
+    private int calculateSum(int[] coordinate, int[][] directions) {
+        int sum = 0;
+        for (int[] dir : directions) {
+            int newX = dir[0] + coordinate[0];
+            int newY = dir[1] + coordinate[1];
+            if (newX >= 0 && newX < numRows && newY >= 0 && newY < numCols) {
+                sum += grid[newX][newY];
+            }
+        }
+        return sum;
+    }
+}
+
+/**
+ * Your neighborSum object will be instantiated and called as such:
+ * neighborSum obj = new neighborSum(grid);
+ * int param_1 = obj.adjacentSum(value);
+ * int param_2 = obj.diagonalSum(value);
+ */

From d9d2a0cfdccbb6d2c0439839abfce89e534ec0f0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 5 Aug 2024 07:45:47 -0700
Subject: [PATCH 2035/2175] Create Find the Number of Winning Players.java

---
 Easy/Find the Number of Winning Players.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Find the Number of Winning Players.java

diff --git a/Easy/Find the Number of Winning Players.java b/Easy/Find the Number of Winning Players.java
new file mode 100644
index 00000000..fd4ea2ba
--- /dev/null
+++ b/Easy/Find the Number of Winning Players.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int winningPlayerCount(int n, int[][] pick) {
+        Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
+        Set<Integer> winners = new HashSet<>();
+        for (int[] p : pick) {
+            map.computeIfAbsent(p[0], k -> new HashMap<>());
+            map.get(p[0]).put(p[1], map.get(p[0]).getOrDefault(p[1], 0) + 1);
+            if (map.get(p[0]).get(p[1]) > p[0]) {
+                winners.add(p[0]);
+            }
+        }
+        return winners.size();
+    }
+}

From ed0f41e4e3f6c4a2bf7b60609d5c4d8ea214e049 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 5 Aug 2024 18:17:23 -0700
Subject: [PATCH 2036/2175] Create Minimum Number of Pushes to Type Word
 II.java

---
 ...imum Number of Pushes to Type Word II.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Minimum Number of Pushes to Type Word II.java

diff --git a/Medium/Minimum Number of Pushes to Type Word II.java b/Medium/Minimum Number of Pushes to Type Word II.java
new file mode 100644
index 00000000..71ec90f6
--- /dev/null
+++ b/Medium/Minimum Number of Pushes to Type Word II.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int minimumPushes(String word) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : word.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        PriorityQueue<Character> pq = new PriorityQueue<>((a, b) -> map.get(b).compareTo(map.get(a)));
+        pq.addAll(map.keySet());
+        int count = 0;
+        int typeMultiple = 1;
+        int counter = 0;
+        while (!pq.isEmpty()) {
+            char removed = pq.poll();
+            count += typeMultiple * map.get(removed);
+            counter++;
+            if (counter == 8) {
+                counter = 0;
+                typeMultiple++;
+            }
+        }
+        return count;
+    }
+}

From 961e9f70e34b77d1d2cf69c745e9ec46cb27cf58 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 Aug 2024 08:13:34 -0700
Subject: [PATCH 2037/2175] Create Shortest Distance After Road Addition
 Queries I.java

---
 ...istance After Road Addition Queries I.java | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Medium/Shortest Distance After Road Addition Queries I.java

diff --git a/Medium/Shortest Distance After Road Addition Queries I.java b/Medium/Shortest Distance After Road Addition Queries I.java
new file mode 100644
index 00000000..19a2ea74
--- /dev/null
+++ b/Medium/Shortest Distance After Road Addition Queries I.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public int[] shortestDistanceAfterQueries(int n, int[][] queries) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < n - 1; i++) {
+            graph.computeIfAbsent(i, k -> new HashSet<>()).add(i + 1);
+        }
+        int[] result = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            int[] query = queries[i];
+            graph.computeIfAbsent(query[0], k -> new HashSet<>()).add(query[1]);
+            result[i] = findDistance(graph, n - 1);
+        }
+        return result;
+    }
+
+    private int findDistance(Map<Integer, Set<Integer>> graph, int target) {
+        Queue<Integer> queue = new LinkedList<>();
+        Set<Integer> visited = new HashSet<>();
+        queue.add(0);
+        int distance = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                Integer node = queue.poll();
+                if (node == target) {
+                    return distance;
+                }
+                for (Integer neighbor : graph.get(node)) {
+                    if (!visited.contains(neighbor)) {
+                        queue.add(neighbor);
+                        visited.add(node);
+                    }
+                }
+            }
+            distance++;
+        }
+        return -1;
+    }
+}

From c0e0d7de8dc5b583bf1086c5d96f4f9345a4ee69 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Aug 2024 15:55:40 -0700
Subject: [PATCH 2038/2175] Create Snake in Matrix.java

---
 Easy/Snake in Matrix.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Snake in Matrix.java

diff --git a/Easy/Snake in Matrix.java b/Easy/Snake in Matrix.java
new file mode 100644
index 00000000..5dce2568
--- /dev/null
+++ b/Easy/Snake in Matrix.java	
@@ -0,0 +1,22 @@
+class Solution {
+
+    private static final Map<String, int[]> COMMAND_TO_DIRECTION = Map.of(
+        "UP", new int[]{-1, 0},
+        "DOWN", new int[]{1, 0},
+        "LEFT", new int[]{0, -1},
+        "RIGHT", new int[]{0, 1}
+    );
+
+    public int finalPositionOfSnake(int n, List<String> commands) {
+        int position = 0;
+        int x = 0;
+        int y = 0;
+        for (String command : commands) {
+            int[] change = COMMAND_TO_DIRECTION.get(command);
+            x += change[0];
+            y += change[1];
+            position = x * n + y;
+        }
+        return position;
+    }
+}

From 0a57dc54af4305a89540e031d7da72c6dcae9548 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 11 Aug 2024 16:28:37 -0700
Subject: [PATCH 2039/2175] Create Count the Number of Good Nodes.java

---
 Medium/Count the Number of Good Nodes.java | 34 ++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Count the Number of Good Nodes.java

diff --git a/Medium/Count the Number of Good Nodes.java b/Medium/Count the Number of Good Nodes.java
new file mode 100644
index 00000000..d100513d
--- /dev/null
+++ b/Medium/Count the Number of Good Nodes.java	
@@ -0,0 +1,34 @@
+class Solution {
+    public int countGoodNodes(int[][] edges) {
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        for (int[] edge : edges) {
+            map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+            map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+        }        
+        int[] result = {0};
+        recurse(map, result, 0, -1);
+        return result[0];
+    }
+
+    private int recurse(Map<Integer, Set<Integer>> map, int[] result, int node, int prevNode) {
+        int count = -1;
+        int total = 1;
+        boolean flag = true;
+        for (Integer conn : map.getOrDefault(node, new HashSet<>())) {
+            if (conn == prevNode) {
+                continue;
+            }
+            int temp = recurse(map, result, conn, node);
+            total += temp;
+            if (count == -1) {
+                count = temp;
+            } else if (count != temp) {
+                flag = false;
+            }
+        }
+        if (flag) {
+            result[0]++;
+        }
+        return total;
+    }
+}

From 8b69a0991f768cb0e7eee430604c769bd24c90e9 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 14 Aug 2024 16:50:03 -0700
Subject: [PATCH 2040/2175] Create Find K-th Smallest Pair Distance.java

---
 Hard/Find K-th Smallest Pair Distance.java | 31 ++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Hard/Find K-th Smallest Pair Distance.java

diff --git a/Hard/Find K-th Smallest Pair Distance.java b/Hard/Find K-th Smallest Pair Distance.java
new file mode 100644
index 00000000..6d84cfa8
--- /dev/null
+++ b/Hard/Find K-th Smallest Pair Distance.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int smallestDistancePair(int[] nums, int k) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int left = 0;
+        int right = nums[n - 1] - nums[0];
+        while (left < right) {
+            int mid = (left + right) / 2;
+            int count = countPairs(nums, mid);
+            if (count < k) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+
+    private int countPairs(int[] nums, int distance) {
+        int count = 0;
+        int n = nums.length;
+        int left = 0;
+        for (int i = 0; i < n; i++) {
+            while (nums[i] - nums[left] > distance) {
+                left++;
+            }
+            count += i - left;
+        }
+        return count;
+    }
+}

From dbff4c4f75e097d5189d566d4bcc28b163efaa1c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 16 Aug 2024 15:05:13 -0700
Subject: [PATCH 2041/2175] Update and rename Maximum Distance in Arrays.java
 to Maximum Distance in Arrays.java

---
 Easy/Maximum Distance in Arrays.java   | 17 -----------------
 Medium/Maximum Distance in Arrays.java | 17 +++++++++++++++++
 2 files changed, 17 insertions(+), 17 deletions(-)
 delete mode 100644 Easy/Maximum Distance in Arrays.java
 create mode 100644 Medium/Maximum Distance in Arrays.java

diff --git a/Easy/Maximum Distance in Arrays.java b/Easy/Maximum Distance in Arrays.java
deleted file mode 100644
index 71a4581d..00000000
--- a/Easy/Maximum Distance in Arrays.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-    public static int maxDistance(List<List<Integer>> arrays) {
-        int min = arrays.get(0).get(0);
-        int max = arrays.get(0).get(arrays.get(0).size()-1);
-        int result = Integer.MIN_VALUE;
-
-        for (int i=1; i<arrays.size(); i++) {
-            result = Math.max(result, Math.abs(arrays.get(i).get(arrays.get(i).size()-1) - min));
-            result = Math.max(result, Math.abs(arrays.get(i).get(0) - max));
-
-            max = Math.max(max, arrays.get(i).get(arrays.get(i).size()-1));
-            min = Math.min(min, arrays.get(i).get(0));
-        }
-        
-        return result;
-    }
-}
diff --git a/Medium/Maximum Distance in Arrays.java b/Medium/Maximum Distance in Arrays.java
new file mode 100644
index 00000000..8205803e
--- /dev/null
+++ b/Medium/Maximum Distance in Arrays.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxDistance(List<List<Integer>> arrays) {
+        int result = 0;
+        int n = arrays.get(0).size();
+        int min = arrays.get(0).get(0);
+        int max = arrays.get(0).get(n - 1);
+        for (int i = 1; i < arrays.size(); i++) {
+            n = arrays.get(i).size();
+            result = Math.max(result, 
+                Math.max(Math.abs(arrays.get(i).get(n - 1) - min), 
+                        Math.abs(max - arrays.get(i).get(0))));
+            min = Math.min(min, arrays.get(i).get(0));
+            max = Math.max(max, arrays.get(i).get(n - 1));
+        }
+        return result;
+    }
+}

From bad1223b35eb5306161d677a54157e84114727dc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Aug 2024 08:29:45 -0700
Subject: [PATCH 2042/2175] Create Count Substrings That Satisfy K-Constraint
 I.java

---
 ...ubstrings That Satisfy K-Constraint I.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Easy/Count Substrings That Satisfy K-Constraint I.java

diff --git a/Easy/Count Substrings That Satisfy K-Constraint I.java b/Easy/Count Substrings That Satisfy K-Constraint I.java
new file mode 100644
index 00000000..9f44425d
--- /dev/null
+++ b/Easy/Count Substrings That Satisfy K-Constraint I.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int countKConstraintSubstrings(String s, int k) {
+        Map<Character, Integer> map = new HashMap<>();
+        int start = 0;
+        int end = 0;
+        int n = s.length();
+        int result = 0;
+        while (end < n) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            end++;
+            while (start < end && map.getOrDefault('0', 0) > k && map.getOrDefault('1', 0) > k) {
+                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
+                start++;
+            }
+            if (map.getOrDefault('0', 0) <= k || map.getOrDefault('1', 0) <= k) {
+                result += end - start;
+            }
+        }
+        return result;
+    }
+}

From 700f9c3e8889b5c97cf03ba4f4859f451422078c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 Aug 2024 17:38:24 -0700
Subject: [PATCH 2043/2175] Create Find the Power of K-Size Subarrays I.java

---
 Easy/Find the Power of K-Size Subarrays I.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Find the Power of K-Size Subarrays I.java

diff --git a/Easy/Find the Power of K-Size Subarrays I.java b/Easy/Find the Power of K-Size Subarrays I.java
new file mode 100644
index 00000000..975c1a3a
--- /dev/null
+++ b/Easy/Find the Power of K-Size Subarrays I.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int[] resultsArray(int[] nums, int k) {
+        if (k == 1) {
+            return nums;
+        }
+        int n = nums.length;
+        int[] result = new int[n - k + 1];
+        Arrays.fill(result, -1);
+        int count = 1;
+        for (int i = 0; i < nums.length - 1; i++) {
+            count = (nums[i + 1] - nums[i] == 1) ? count + 1 : 1;
+            if (count >= k) {
+                result[i - k + 2] = nums[i + 1];
+            }
+        }
+        return result;
+    }
+}

From 9f4be8534e7a2658e69fc80c9f52722451071f04 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 22 Aug 2024 17:22:21 -0700
Subject: [PATCH 2044/2175] Create Fraction Addition and Subtraction.java

---
 Medium/Fraction Addition and Subtraction.java | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Fraction Addition and Subtraction.java

diff --git a/Medium/Fraction Addition and Subtraction.java b/Medium/Fraction Addition and Subtraction.java
new file mode 100644
index 00000000..3d26da63
--- /dev/null
+++ b/Medium/Fraction Addition and Subtraction.java	
@@ -0,0 +1,42 @@
+class Solution {
+    public String fractionAddition(String expression) {
+        int numerator = 0;
+        int denominator = 1;
+        int idx = 0;
+        int n = expression.length();
+        while (idx < n) {
+            int currNumerator = 0;
+            int currDenominator = 0;
+            boolean negative = false;
+            if (expression.charAt(idx) == '-' || expression.charAt(idx) == '+') {
+                negative = expression.charAt(idx) == '-' ? true : false;
+                idx++;
+            }
+            while (Character.isDigit(expression.charAt(idx))) {
+                currNumerator = currNumerator * 10 + Character.getNumericValue(expression.charAt(idx));
+                idx++;
+            }
+            if (negative) {
+                currNumerator *= -1;
+            }
+            idx++;
+            while (idx < n && Character.isDigit(expression.charAt(idx))) {
+                currDenominator = currDenominator * 10 + Character.getNumericValue(expression.charAt(idx));
+                idx++;
+            }
+            numerator = numerator * currDenominator + currNumerator * denominator;
+            denominator = denominator * currDenominator;
+        }
+        int gcd = Math.abs(gcd(numerator, denominator));
+        numerator /= gcd;
+        denominator /= gcd;
+        return numerator + "/" + denominator;
+    }
+
+    private int gcd(int a, int b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+}

From 17c7839ced9bc02a8ad2595706989700a1caab41 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 25 Aug 2024 17:23:09 -0700
Subject: [PATCH 2045/2175] Create Final Array State After K Multiplication
 Operations I.java

---
 ...e After K Multiplication Operations I.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Easy/Final Array State After K Multiplication Operations I.java

diff --git a/Easy/Final Array State After K Multiplication Operations I.java b/Easy/Final Array State After K Multiplication Operations I.java
new file mode 100644
index 00000000..da5670de
--- /dev/null
+++ b/Easy/Final Array State After K Multiplication Operations I.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int[] getFinalState(int[] nums, int k, int multiplier) {
+        int n = nums.length;
+        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt((int[] o) -> o[0])
+            .thenComparingInt(o -> o[1]));
+        for (int i = 0; i < n; i++) {
+            pq.add(new int[]{nums[i], i});
+        }
+        while (k-- > 0) {
+            int[] removed = pq.remove();
+            int value = removed[0];
+            int index = removed[1];
+            int newValue = value * multiplier;
+            pq.add(new int[]{newValue, index});
+        }
+        int[] result = new int[n];
+        while (!pq.isEmpty()) {
+            int[] removed = pq.remove();
+            int value = removed[0];
+            int index = removed[1];
+            result[index] = value;
+        }
+        return result;
+    }
+}

From d717b453af22cd7a8f21cf3db668b30edbb7734e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 1 Sep 2024 07:36:13 -0700
Subject: [PATCH 2046/2175] Create Add Two Polynomials Represented as Linked
 Lists.java

---
 ...lynomials Represented as Linked Lists.java | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 Medium/Add Two Polynomials Represented as Linked Lists.java

diff --git a/Medium/Add Two Polynomials Represented as Linked Lists.java b/Medium/Add Two Polynomials Represented as Linked Lists.java
new file mode 100644
index 00000000..f7eafe3a
--- /dev/null
+++ b/Medium/Add Two Polynomials Represented as Linked Lists.java	
@@ -0,0 +1,43 @@
+/**
+ * Definition for polynomial singly-linked list.
+ * class PolyNode {
+ *     int coefficient, power;
+ *     PolyNode next = null;
+ 
+ *     PolyNode() {}
+ *     PolyNode(int x, int y) { this.coefficient = x; this.power = y; }
+ *     PolyNode(int x, int y, PolyNode next) { this.coefficient = x; this.power = y; this.next = next; }
+ * }
+ */
+
+class Solution {
+    public PolyNode addPoly(PolyNode poly1, PolyNode poly2) {
+        Map<Integer, Integer> powerToValue = new HashMap<>();
+        populateMap(powerToValue, poly1);
+        populateMap(powerToValue, poly2);
+        List<Integer> powerKeys = new ArrayList<>(powerToValue.keySet());
+        Collections.sort(powerKeys);
+        PolyNode dummy = new PolyNode();
+        PolyNode curr = dummy;
+        for (int i = powerKeys.size() - 1; i >= 0; i--) {
+            if (powerToValue.get(powerKeys.get(i)) == 0) {
+                continue;
+            }
+            PolyNode node = new PolyNode(powerToValue.get(powerKeys.get(i)), powerKeys.get(i));
+            curr.next = node;
+            curr = curr.next;
+        }
+        return dummy.next;
+    }
+
+    private void populateMap(Map<Integer, Integer> powerToValue, PolyNode poly) {
+        while (poly != null) {
+            PolyNode node = poly;
+            int power = node.power;
+            if (node.coefficient != 0) {
+                powerToValue.put(power, powerToValue.getOrDefault(power, 0) + node.coefficient);
+            }
+            poly = poly.next;
+        }
+    }
+}

From abc7fd46d0bd7d89fb9534dc4487f107a4293a21 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 1 Sep 2024 17:39:57 -0700
Subject: [PATCH 2047/2175] Update Find the Student that Will Replace the
 Chalk.java

---
 ...e Student that Will Replace the Chalk.java | 34 +++++++++++--------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/Medium/Find the Student that Will Replace the Chalk.java b/Medium/Find the Student that Will Replace the Chalk.java
index 8ee73065..bdf79d9a 100644
--- a/Medium/Find the Student that Will Replace the Chalk.java	
+++ b/Medium/Find the Student that Will Replace the Chalk.java	
@@ -1,17 +1,23 @@
 class Solution {
-  public int chalkReplacer(int[] chalk, int k) {
-    int initialResult = chalkReplacerHelper(chalk, k);
-    return initialResult != -1 ? initialResult
-        : chalkReplacerHelper(chalk, k % Arrays.stream(chalk).sum());
-  }
-
-  private int chalkReplacerHelper(int[] chalk, int k) {
-    for (int i = 0; i < chalk.length; i++) {
-      if (k - chalk[i] < 0) {
-        return i;
-      }
-      k -= chalk[i];
+    public int chalkReplacer(int[] chalk, int k) {
+        int n = chalk.length;
+        long[] prefixSum = new long[n];
+        prefixSum[0] = chalk[0];
+        for (int i = 1; i < n; i++) {
+            prefixSum[i] = chalk[i] + prefixSum[i - 1]; 
+        }
+        long total = prefixSum[n - 1];
+        long remaining = k % total;
+        int left = 0;
+        int right = n - 1;
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (prefixSum[mid] <= remaining) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return right;
     }
-    return -1;
-  }
 }

From 391f4c4f861b0e95ae7281346e190c2b3ef7dff4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 Sep 2024 06:11:54 -0700
Subject: [PATCH 2048/2175] Update Sum of Digits of String After Convert.java

---
 ...Sum of Digits of String After Convert.java | 29 ++++++++++---------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/Easy/Sum of Digits of String After Convert.java b/Easy/Sum of Digits of String After Convert.java
index c86c724c..3b78aaae 100644
--- a/Easy/Sum of Digits of String After Convert.java	
+++ b/Easy/Sum of Digits of String After Convert.java	
@@ -1,17 +1,18 @@
 class Solution {
-  public int getLucky(String s, int k) {
-    StringBuilder sb = new StringBuilder();
-    for (char c : s.toCharArray()) {
-      sb.append(c - 'a' + 1);
+    public int getLucky(String s, int k) {
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            sb.append(c - 'a' + 1);
+        }
+        while (k-- > 0) {
+            String temp = sb.toString();
+            sb.setLength(0);
+            int val = 0;
+            for (char c : temp.toCharArray()) {
+                val += Character.getNumericValue(c);
+            }
+            sb.append(val);
+        }
+        return Integer.parseInt(sb.toString());
     }
-    String num = sb.toString();
-    while (k-- > 0) {
-      int sum = 0;
-      for (char c : num.toCharArray()) {
-        sum += Character.getNumericValue(c);
-      }
-      num = String.valueOf(sum);
-    }
-    return Integer.parseInt(num);
-  }
 }

From e1dcfeaa1f25a8985962ec1f2544cf93fef7823d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 Sep 2024 18:14:48 -0700
Subject: [PATCH 2049/2175] Create Walking Robot Simulation.java

---
 Medium/Walking Robot Simulation.java | 41 ++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 Medium/Walking Robot Simulation.java

diff --git a/Medium/Walking Robot Simulation.java b/Medium/Walking Robot Simulation.java
new file mode 100644
index 00000000..bfc2784f
--- /dev/null
+++ b/Medium/Walking Robot Simulation.java	
@@ -0,0 +1,41 @@
+class Solution {
+    private static final int[][] DIRECTIONS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+    private static final int HASH_MULTIPLIER = 60001;
+
+    public int robotSim(int[] commands, int[][] obstacles) {
+        Set<Integer> obstacleSet = new HashSet<>();
+        for (int[] obstacle : obstacles) {
+            obstacleSet.add(hashCoordinates(obstacle[0], obstacle[1]));
+        }
+        int maxDistance = 0;
+        int currentDirection = 0;
+        int x = 0;
+        int y = 0;
+        for (int command : commands) {
+            if (command == -1) {
+                currentDirection = (currentDirection + 1) % 4;
+                continue;
+            }
+            if (command == -2) {
+                currentDirection = (currentDirection + 3) % 4;
+                continue;
+            }
+            int[] direction = DIRECTIONS[currentDirection];
+            for (int i = 0; i < command; i++) {
+                int nextX = x + direction[0];
+                int nextY = y + direction[1];
+                if (obstacleSet.contains(hashCoordinates(nextX, nextY))) {
+                    break;
+                }
+                x = nextX;
+                y = nextY;
+            }
+            maxDistance = Math.max(maxDistance, x * x + y * y);
+        }
+        return maxDistance;
+    }
+
+    private static int hashCoordinates(int x, int y) {
+        return x + HASH_MULTIPLIER * y;
+    }
+}

From 0dd2c3bc6121d307e42223df055bc7d0e1d01bb7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Sep 2024 08:11:01 -0700
Subject: [PATCH 2050/2175] Create Diagonal Traverse II.java

---
 Medium/Diagonal Traverse II.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Diagonal Traverse II.java

diff --git a/Medium/Diagonal Traverse II.java b/Medium/Diagonal Traverse II.java
new file mode 100644
index 00000000..dabfc5ef
--- /dev/null
+++ b/Medium/Diagonal Traverse II.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int[] findDiagonalOrder(List<List<Integer>> nums) {
+        Queue<int[]> queue = new LinkedList<>();
+        List<Integer> result = new ArrayList<>();
+        queue.add(new int[]{0, 0});
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int x = removed[0];
+            int y = removed[1];
+            result.add(nums.get(x).get(y));
+            // move down in column first
+            if (y == 0 && x + 1 < nums.size()) {
+                queue.add(new int[]{x + 1, y});
+            }
+            // then pick the next element in row
+            if (y + 1 < nums.get(x).size()) {
+                queue.add(new int[]{x, y + 1});
+            }
+        }
+        int[] ans = new int[result.size()];
+        for (int i = 0; i < result.size(); i++) {
+            ans[i] = result.get(i);
+        }
+        return ans;
+    }
+}

From d214eff088dc8dc903de22e3f672e7ebce83f633 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Sep 2024 08:25:09 -0700
Subject: [PATCH 2051/2175] Create Sum of All Subset XOR Totals.java

---
 Easy/Sum of All Subset XOR Totals.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Easy/Sum of All Subset XOR Totals.java

diff --git a/Easy/Sum of All Subset XOR Totals.java b/Easy/Sum of All Subset XOR Totals.java
new file mode 100644
index 00000000..fe82567a
--- /dev/null
+++ b/Easy/Sum of All Subset XOR Totals.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int subsetXORSum(int[] nums) {
+        return recurse(nums, 0, 0);
+    }
+
+    private int recurse(int[] nums, int idx, int currXor) {
+        if (idx == nums.length) {
+            return currXor;
+        }
+        int performXor = recurse(nums, idx + 1, currXor ^ nums[idx]);
+        int notPerformXor = recurse(nums, idx + 1, currXor);
+        return performXor + notPerformXor;
+    }
+}

From a13c10b8f5ed445486e4668b5981486212488422 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Sep 2024 09:52:37 -0700
Subject: [PATCH 2052/2175] Update Lowest Common Ancestor of a Binary Tree
 III.java

---
 ... Common Ancestor of a Binary Tree III.java | 48 +++++++++----------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/Medium/Lowest Common Ancestor of a Binary Tree III.java b/Medium/Lowest Common Ancestor of a Binary Tree III.java
index 26269fcc..098b0f86 100644
--- a/Medium/Lowest Common Ancestor of a Binary Tree III.java	
+++ b/Medium/Lowest Common Ancestor of a Binary Tree III.java	
@@ -9,30 +9,30 @@ class Node {
 */
 
 class Solution {
-  public Node lowestCommonAncestor(Node p, Node q) {
-    int pDepth = getDepth(p);
-    int qDepth = getDepth(q);
-    while (pDepth > qDepth) {
-      pDepth--;
-      p = p.parent;
+    public Node lowestCommonAncestor(Node p, Node q) {
+        int pDepth = getDepth(p);
+        int qDepth = getDepth(q);
+        while (pDepth > qDepth) {
+            pDepth--;
+            p = p.parent;
+        }
+        while (qDepth > pDepth) {
+            qDepth--;
+            q = q.parent;
+        }
+        while (p != q) {
+            p = p.parent;
+            q = q.parent;
+        }
+        return p;
     }
-    while (pDepth < qDepth) {
-      qDepth--;
-      q = q.parent;
-    }
-    while (p != q) {
-      p = p.parent;
-      q = q.parent;
-    }
-    return p;
-  }
-  
-  private int getDepth(Node node) {
-    int depth = 0;
-    while (node != null) {
-      depth++;
-      node = node.parent;
+
+    private int getDepth(Node node) {
+        int depth = 0;
+        while (node != null) {
+            depth++;
+            node = node.parent;
+        }
+        return depth;
     }
-    return depth;
-  }
 }

From 0a57a4f4521e99065dd2c7cdeaad99732ef85b9a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Sep 2024 17:22:56 -0700
Subject: [PATCH 2053/2175] Update Find Missing Observations.java

---
 Medium/Find Missing Observations.java | 32 +++++++++++++++------------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/Medium/Find Missing Observations.java b/Medium/Find Missing Observations.java
index 7b738edc..fe724572 100644
--- a/Medium/Find Missing Observations.java	
+++ b/Medium/Find Missing Observations.java	
@@ -1,17 +1,21 @@
 class Solution {
-  public int[] missingRolls(int[] rolls, int mean, int n) {
-    int currSum = Arrays.stream(rolls).sum();
-    int missingSum = mean * (n + rolls.length) - currSum;
-    if (missingSum > n * 6 || missingSum < n) {
-      return new int[]{};
+    public int[] missingRolls(int[] rolls, int mean, int n) {
+        int m = rolls.length;
+        int sum = 0;
+        for (int roll : rolls) {
+            sum += roll;
+        }
+        int expectedSum = mean * (n + m);
+        int remaining = expectedSum - sum;
+        if (remaining > 6 * n || remaining < n) {
+            return new int[]{};
+        }
+        int[] result = new int[n];
+        Arrays.fill(result, remaining / n);
+        remaining = remaining % n;
+        for (int i = 0; i < remaining; i++) {
+            result[i]++;
+        }        
+        return result;
     }
-    int[] ans = new int[n];
-    int part = missingSum / n;
-    int remainder = missingSum % n;
-    Arrays.fill(ans, part);
-    for (int i = 0; i < remainder; i++) {
-      ans[i]++;
-    }
-    return ans;
-  }
 }

From 4137cce7391bef40a4fff4400dcf863c0115596f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Sep 2024 17:30:29 -0700
Subject: [PATCH 2054/2175] Update Buildings With an Ocean View.java

---
 Medium/Buildings With an Ocean View.java | 25 ++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/Medium/Buildings With an Ocean View.java b/Medium/Buildings With an Ocean View.java
index b9735daa..6d52576e 100644
--- a/Medium/Buildings With an Ocean View.java	
+++ b/Medium/Buildings With an Ocean View.java	
@@ -1,13 +1,18 @@
 class Solution {
-  public int[] findBuildings(int[] heights) {
-    List<Integer> oceanViewBuildings = new ArrayList<>();
-    int maxHeight = 0;
-    for (int i = heights.length - 1; i >= 0; i--) {
-      if (heights[i] > maxHeight) {
-        oceanViewBuildings.add(i);
-      }
-      maxHeight = Math.max(maxHeight, heights[i]);
+    public int[] findBuildings(int[] heights) {
+        List<Integer> result = new ArrayList<>();
+        int maxHeight = -1;
+        for (int i = heights.length - 1; i >= 0; i--) {
+            if (heights[i] > maxHeight) {
+                result.add(i);
+            }
+            maxHeight = Math.max(maxHeight, heights[i]);
+        }
+        int[] ans = new int[result.size()];
+        Collections.reverse(result);
+        for (int i = 0; i < result.size(); i++) {
+            ans[i] = result.get(i);
+        }
+        return ans;
     }
-    return oceanViewBuildings.stream().sorted().mapToInt(Integer::valueOf).toArray();
-  }
 }

From 88ca3f65bd13f7af1d3836e56dc7fed521893d80 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 6 Sep 2024 07:05:29 -0700
Subject: [PATCH 2055/2175] Create Delete Nodes From Linked List Present in
 Array.java

---
 ...des From Linked List Present in Array.java | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Delete Nodes From Linked List Present in Array.java

diff --git a/Medium/Delete Nodes From Linked List Present in Array.java b/Medium/Delete Nodes From Linked List Present in Array.java
new file mode 100644
index 00000000..ff184902
--- /dev/null
+++ b/Medium/Delete Nodes From Linked List Present in Array.java	
@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode modifiedList(int[] nums, ListNode head) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+        while (head != null && set.contains(head.val)) {
+            head = head.next;
+        }
+        ListNode newHead = head;
+        ListNode curr = head;
+        while (curr.next != null) {
+            if (set.contains(curr.next.val)) {
+                curr.next = curr.next.next;
+            } else {
+                curr = curr.next;
+            }
+        }
+        return newHead;
+    }
+}

From fb8b21f8a92f46d47a505e1e05a2a66429afda05 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 6 Sep 2024 07:42:55 -0700
Subject: [PATCH 2056/2175] Create Making A Large Island.java

---
 Hard/Making A Large Island.java | 68 +++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 Hard/Making A Large Island.java

diff --git a/Hard/Making A Large Island.java b/Hard/Making A Large Island.java
new file mode 100644
index 00000000..d1026bd7
--- /dev/null
+++ b/Hard/Making A Large Island.java	
@@ -0,0 +1,68 @@
+class Solution {
+
+    private static final int[][] DIRS = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
+
+    public int largestIsland(int[][] grid) {
+        int n = grid.length;
+        int tag = 2;
+        int result = 0;
+        Map<Integer, Integer> tagToAreaMapping = new HashMap<>();
+        // Calculate area without changing 0 to 1 & tag each island for future reference
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 1) {
+                    tagToAreaMapping.put(tag, dfs(grid, i, j, tag));
+                    result = Math.max(result, tagToAreaMapping.get(tag));
+                    tag++;
+                }
+            }
+        }
+        // Now start changing each 0 to 1 & add the area of all connected islands by referencing their tags
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 0) {
+                    Set<Integer> visited = new HashSet<>();
+                    int currArea = 1;
+                    List<int[]> moves = getMoves(i, j, n);
+                    for (int[] move : moves) {
+                        int x = move[0];
+                        int y = move[1];
+                        int currTag = grid[x][y];
+                        if (currTag > 1 && visited.add(currTag)) {
+                            currArea += tagToAreaMapping.get(currTag);
+                        }
+                    }
+                    result = Math.max(result, currArea);
+                }
+            }
+        }
+        return result;
+    }
+
+    private int dfs(int[][] grid, int x, int y, int tag) {
+        int area = 1;
+        int n = grid.length;
+        grid[x][y] = tag;
+        List<int[]> moves = getMoves(x, y, n);
+        for (int[] move : moves) {
+            int i = move[0];
+            int j = move[1];
+            if (grid[i][j] == 1) {
+                area += dfs(grid, i, j, tag);
+            }
+        }
+        return area;
+    }
+
+    private List<int[]> getMoves(int x, int y, int n) {
+        List<int[]> moves = new ArrayList<>();
+        for (int[] dir : DIRS) {
+            int newX = x + dir[0];
+            int newY = y + dir[1];
+            if (newX >= 0 && newX < n && newY >= 0 && newY < n) {
+                moves.add(new int[]{newX, newY});
+            }
+        }
+        return moves;
+    }
+}

From 5028a9e5f102e02eaa78f86313087d21181fb841 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 6 Sep 2024 08:43:03 -0700
Subject: [PATCH 2057/2175] Create Max Consecutive Ones III.java

---
 Medium/Max Consecutive Ones III.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Max Consecutive Ones III.java

diff --git a/Medium/Max Consecutive Ones III.java b/Medium/Max Consecutive Ones III.java
new file mode 100644
index 00000000..cec14a87
--- /dev/null
+++ b/Medium/Max Consecutive Ones III.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int longestOnes(int[] nums, int k) {
+        int start = 0;
+        int end = 0;
+        int flipped = 0;
+        int n = nums.length;
+        int max = 0;
+        while (end < nums.length) {
+            if (nums[end] == 0) {
+                flipped++;
+            }
+            end++;
+            while (start < end && flipped > k) {
+                if (nums[start] == 0) {
+                    flipped--;
+                }
+                start++;
+            }
+            max = Math.max(max, end - start);
+        }
+        return max;
+    }
+}

From b54f9b0024f91c558910d8724bc601bd3400cf4c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 6 Sep 2024 09:03:57 -0700
Subject: [PATCH 2058/2175] Update Valid Number.java

---
 Hard/Valid Number.java | 106 +++++++++++++++--------------------------
 1 file changed, 39 insertions(+), 67 deletions(-)

diff --git a/Hard/Valid Number.java b/Hard/Valid Number.java
index d9a68285..1cdebfa8 100644
--- a/Hard/Valid Number.java	
+++ b/Hard/Valid Number.java	
@@ -1,90 +1,62 @@
 class Solution {
-        public boolean isNumber(String s) {
-        s = s.trim();
-        char[] ch = s.toCharArray();
+    public boolean isNumber(String s) {
         int idx = 0;
-        int n = ch.length;
-        boolean signFound = false;
-        boolean decimalFound = false;
-        boolean numFound = false;
-        boolean expoFound = false;
-
+        boolean isDecimal = false;
+        boolean isDigit = false;
+        boolean digitsBeforeDecimal = false;
+        boolean digitsAfterDecimal = false;
+        int n = s.length();
+        if (s.charAt(idx) == '-' || s.charAt(idx) == '+') {
+            idx++;
+        }
         while (idx < n) {
-            if (ch[idx] == '+' || ch[idx] == '-') {
-                if (numFound || signFound || decimalFound) {
+            if (s.charAt(idx) == '.') {
+                if (isDecimal) {
                     return false;
                 }
-
-                signFound = true;
-            }
-            else if (ch[idx] == '.') {
-                if (decimalFound) {
+                isDecimal = true;
+            } else if (s.charAt(idx) == 'e' || s.charAt(idx) == 'E') {
+                if (!isDigit) {
                     return false;
                 }
-                decimalFound = true;
-            }
-            else if (Character.isLetter(ch[idx])) {
-                if (ch[idx] == 'e') {
-                    if (!numFound) {
-                        return false;
-                    }
-                    idx++;
-                    expoFound = true;
-                    break;
-                }
-                else {
+                boolean valid = isValidExponent(s, idx + 1);
+                if (!valid) {
                     return false;
                 }
-            }
-            else if (Character.isDigit(ch[idx])) {
-                numFound = true;
-            }
-            else if (ch[idx] == ' ') {
-                if (numFound || signFound || decimalFound) {
-                    return false;
+                break;
+            } else if (Character.isDigit(s.charAt(idx))) {
+                if (isDecimal) {
+                    digitsAfterDecimal = true;
+                } else {
+                    digitsBeforeDecimal = true;
                 }
+                isDigit = true;
+            } else {
+                return false;
             }
-
             idx++;
         }
-
-        if (!numFound) {
-            return false;
+        if (isDecimal) {
+            return digitsBeforeDecimal || digitsAfterDecimal;
         }
+        return isDigit;
+    } 
 
-        if (expoFound && idx == n) {
+    private boolean isValidExponent(String s, int idx) {
+        if (idx == s.length()) {
             return false;
         }
-
-        signFound = false;
-        numFound = false;
-        while (idx < n) {
-            if (ch[idx] == '.') {
-                return false;
-            }
-            else if (ch[idx] == '+' || ch[idx] == '-') {
-                if (signFound) {
-                    return false;
-                }
-                if (numFound) {
-                    return false;
-                }
-                signFound = true;
-            }
-            else if (Character.isDigit(ch[idx])) {
-                numFound = true;
-            }
-            else {
+        if (s.charAt(idx) == '-' || s.charAt(idx) == '+') {
+            idx++;
+        }
+        boolean digitFound = false;
+        while (idx < s.length()) {
+            if (!Character.isDigit(s.charAt(idx))) {
                 return false;
             }
-
+            digitFound = true;
             idx++;
         }
-
-        if (expoFound && !numFound) {
-            return false;
-        }
-
-        return true;
+        return digitFound;
     }
 }

From 6a4ac34e8808f4eff237a7d4d4a95eb79d8e3a47 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 7 Sep 2024 14:32:30 -0700
Subject: [PATCH 2059/2175] Update Exclusive Time of Functions.java

---
 Medium/Exclusive Time of Functions.java | 50 +++++++++++--------------
 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/Medium/Exclusive Time of Functions.java b/Medium/Exclusive Time of Functions.java
index 8212e0c0..cd85e84c 100644
--- a/Medium/Exclusive Time of Functions.java	
+++ b/Medium/Exclusive Time of Functions.java	
@@ -1,33 +1,25 @@
 class Solution {
-  public int[] exclusiveTime(int n, List<String> logs) {
-    int[] result = new int[n];
-    Stack<Log> stack = new Stack<>();
-    for (String log : logs) {
-      Log currentLog = new Log(log);
-      if (currentLog.isStart) {
-        stack.push(currentLog);
-      } else {
-        Log topLog = stack.pop();
-        result[topLog.id] += currentLog.time - topLog.time + 1 - topLog.overLappingTime;
-        if (!stack.isEmpty()) {
-          stack.peek().overLappingTime += currentLog.time - topLog.time + 1;
+    public int[] exclusiveTime(int n, List<String> logs) {
+        Stack<Integer> stack = new Stack<>();
+        int[] result = new int[n];
+        int lastTimestamp = 0;
+        for (String log : logs) {
+            String[] split = log.split(":");
+            int id = Integer.parseInt(split[0]);
+            int timestamp = Integer.parseInt(split[2]);
+            if (split[1].equals("start")) {
+                // We consider timestamp as part of current computation 
+                if (!stack.isEmpty()) {
+                    result[stack.peek()] += timestamp - lastTimestamp;
+                }
+                stack.push(id);
+                lastTimestamp = timestamp;
+            } else {
+                // We consider timestamp as part of previous computation
+                result[stack.pop()] += timestamp - lastTimestamp + 1;
+                lastTimestamp = timestamp + 1;
+            }
         }
-      }
+        return result;
     }
-    return result;
-  }
-
-  private static class Log {
-    public int id;
-    public boolean isStart;
-    public int time;
-    public int overLappingTime;
-
-    public Log(String log) {
-      String[] split = log.split(":");
-      this.id = Integer.parseInt(split[0]);
-      this.isStart = split[1].equals("start");
-      this.time = Integer.parseInt(split[2]);
-    }
-  }
 }

From 6f1feb4a469506b8555f0b0ef8f0e367535874ee Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 7 Sep 2024 16:08:59 -0700
Subject: [PATCH 2060/2175] Update Product of Two Run-Length Encoded
 Arrays.java

---
 ...duct of Two Run-Length Encoded Arrays.java | 64 ++++++++-----------
 1 file changed, 28 insertions(+), 36 deletions(-)

diff --git a/Medium/Product of Two Run-Length Encoded Arrays.java b/Medium/Product of Two Run-Length Encoded Arrays.java
index 7aa0b117..4aab9bc8 100644
--- a/Medium/Product of Two Run-Length Encoded Arrays.java	
+++ b/Medium/Product of Two Run-Length Encoded Arrays.java	
@@ -1,39 +1,31 @@
 class Solution {
-  public List<List<Integer>> findRLEArray(int[][] encoded1, int[][] encoded2) {
-    int idxOne = 0;
-    int idxTwo = 0;
-    List<List<Integer>> result = new ArrayList<>();
-    while (idxOne < encoded1.length && idxTwo < encoded2.length) {
-      int valueOne = encoded1[idxOne][0];
-      int frequencyOne = 0;
-      while (idxOne < encoded1.length && encoded1[idxOne][0] == valueOne) {
-        frequencyOne += encoded1[idxOne++][1];
-      }
-      idxOne--;
-      encoded1[idxOne][1] = frequencyOne;
-      int valueTwo = encoded2[idxTwo][0];
-      int frequencyTwo = 0;
-      while (idxTwo < encoded2.length && encoded2[idxTwo][0] == valueTwo) {
-        frequencyTwo += encoded2[idxTwo++][1];
-      }
-      idxTwo--;
-      encoded2[idxTwo][1] = frequencyTwo;
-      int prod = encoded1[idxOne][0] * encoded2[idxTwo][0];
-      int frequency = Math.min(encoded1[idxOne][1], encoded2[idxTwo][1]);
-      if (result.size() > 0 && result.get(result.size() - 1).get(0) == prod) {
-        result.get(result.size() - 1).set(1, result.get(result.size() - 1).get(1) + frequency);
-      } else {
-        result.add(Arrays.asList(prod, frequency));
-      }
-      encoded1[idxOne][1] -= frequency;
-      encoded2[idxTwo][1] -= frequency;
-      if (encoded1[idxOne][1] == 0) {
-        idxOne++;
-      }
-      if (encoded2[idxTwo][1] == 0) {
-        idxTwo++;
-      }
+    public List<List<Integer>> findRLEArray(int[][] encoded1, int[][] encoded2) {
+        int idxOne = 0;
+        int idxTwo = 0;
+        List<List<Integer>> result = new ArrayList<>();
+        while (idxOne < encoded1.length && idxTwo < encoded2.length) {
+            int valOne = encoded1[idxOne][0];
+            int valTwo = encoded2[idxTwo][0];
+            int countOne = encoded1[idxOne][1];
+            int countTwo = encoded2[idxTwo][1];
+            int value = valOne * valTwo;
+            int count = Math.min(countOne, countTwo);
+            encoded1[idxOne][1] -= count;
+            encoded2[idxTwo][1] -= count;
+            if (encoded1[idxOne][1] == 0) {
+                idxOne++;
+            }
+            if (encoded2[idxTwo][1] == 0) {
+                idxTwo++;
+            }
+            if (!result.isEmpty() && result.get(result.size() - 1).get(0) == value) {
+                int existingCount = result.get(result.size() - 1).get(1);
+                int newCount = existingCount + count;
+                result.get(result.size() - 1).set(1, newCount);
+            } else {
+                result.add(Arrays.asList(value, count));
+            }
+        }
+        return result;
     }
-    return result;
-  }
 }

From f4665a1b78411741240061f2a93b5dc4a7999410 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Sep 2024 11:56:52 -0700
Subject: [PATCH 2061/2175] Update Minimum Time to Collect All Apples in a
 Tree.java

---
 ... Time to Collect All Apples in a Tree.java | 44 ++++++++++---------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/Medium/Minimum Time to Collect All Apples in a Tree.java b/Medium/Minimum Time to Collect All Apples in a Tree.java
index 24feb762..0e54b3ec 100644
--- a/Medium/Minimum Time to Collect All Apples in a Tree.java	
+++ b/Medium/Minimum Time to Collect All Apples in a Tree.java	
@@ -1,25 +1,27 @@
 class Solution {
-  public int minTime(int n, int[][] edges, List<Boolean> hasApple) {
-    Map<Integer, Set<Integer>> tree = new HashMap<>();
-    for (int[] edge : edges) {
-      tree.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
-      tree.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    public int minTime(int n, int[][] edges, List<Boolean> hasApple) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int[] edge : edges) {
+            map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            map.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+        }
+        return recurse(0, -1, map, hasApple);
     }
-    Set<Integer> visited = new HashSet<>();
-    return dfs(0, hasApple, visited, tree);
-  }
-  
-  private int dfs(int node, List<Boolean> hasApple, Set<Integer> visited, Map<Integer, Set<Integer>> tree) {
-    visited.add(node);
-    int result = 0;
-    for (Integer child : tree.getOrDefault(node, new HashSet<>())) {
-      if (!visited.contains(child)) {
-        result += dfs(child, hasApple, visited, tree);
-      }
+
+    private int recurse(int node, int parent, Map<Integer, List<Integer>> graph, List<Boolean> hasApple) {
+        if (!graph.containsKey(node)) {
+            return 0;
+        }
+        int time = 0;
+        for (Integer conn: graph.get(node)) {
+            if (conn == parent) {
+                continue;
+            }
+            int connTime = recurse(conn, node, graph, hasApple);
+            if (connTime > 0 || hasApple.get(conn)) {
+                time += connTime + 2;
+            }
+        }
+        return time;
     }
-    if ((result > 0 || hasApple.get(node)) && node != 0) {
-      result += 2;
-    }
-    return result;
-  }
 }

From 56554ae1b5bbc84477ce970a0e70578697429c5b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Sep 2024 12:08:47 -0700
Subject: [PATCH 2062/2175] Update Meeting Scheduler.java

---
 Medium/Meeting Scheduler.java | 37 ++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/Medium/Meeting Scheduler.java b/Medium/Meeting Scheduler.java
index d5bf6b16..aeb5d8e9 100644
--- a/Medium/Meeting Scheduler.java	
+++ b/Medium/Meeting Scheduler.java	
@@ -1,21 +1,22 @@
 class Solution {
-  public List<Integer> minAvailableDuration(int[][] slots1, int[][] slots2, int duration) {
-    Arrays.sort(slots1, Comparator.comparingInt(o -> o[0]));
-    Arrays.sort(slots2, Comparator.comparingInt(o -> o[0]));
-    int idxOne = 0;
-    int idxTwo = 0;
-    while (idxOne < slots1.length && idxTwo < slots2.length) {
-      int maxStart = Math.max(slots1[idxOne][0], slots2[idxTwo][0]);
-      int minEnd = Math.min(slots1[idxOne][1], slots2[idxTwo][1]);
-      if (minEnd - maxStart >= duration) {
-        return Arrays.asList(maxStart, maxStart + duration);
-      }
-      if (slots1[idxOne][1] > slots2[idxTwo][1]) {
-        idxTwo++;
-      } else {
-        idxOne++;
-      }
+    public List<Integer> minAvailableDuration(int[][] slots1, int[][] slots2, int duration) {
+        Arrays.sort(slots1, Comparator.comparingInt(o -> o[0]));
+        Arrays.sort(slots2, Comparator.comparingInt(o -> o[0]));
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < slots1.length && idxTwo < slots2.length) {
+            int maxStart = Math.max(slots1[idxOne][0], slots2[idxTwo][0]);
+            int minEnd = Math.min(slots1[idxOne][1], slots2[idxTwo][1]);
+            if (minEnd - maxStart >= duration) {
+                return List.of(maxStart, maxStart + duration);
+            }
+            if (minEnd == slots1[idxOne][1]) {
+                idxOne++;
+            }
+            if (minEnd == slots2[idxTwo][1]) {
+                idxTwo++;
+            }
+        }
+        return Collections.emptyList();
     }
-    return new ArrayList<>();
-  }
 }

From 3ba562353c17ddfcc35c87757145c3bfd5a21558 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Sep 2024 15:49:02 -0700
Subject: [PATCH 2063/2175] Create Alternating Groups I.java

---
 Easy/Alternating Groups I.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Alternating Groups I.java

diff --git a/Easy/Alternating Groups I.java b/Easy/Alternating Groups I.java
new file mode 100644
index 00000000..9730d5ea
--- /dev/null
+++ b/Easy/Alternating Groups I.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int numberOfAlternatingGroups(int[] colors) {
+        int count = 0;
+        int n = colors.length;
+        for (int i = 0; i < n - 2; i++) {
+            if (colors[i + 1]  != colors[i] && colors[i + 1] != colors[i + 2]) {
+                count++;
+            }
+        }
+        if (colors[n - 2] != colors[n - 1] && colors[n - 2] == colors[0]) {
+            count++;
+        }
+        if (colors[n - 1] != colors[0] && colors[n - 1] == colors[1]) {
+            count++;
+        }
+        return count;
+    }
+}

From bd41f382ab668b5de9e605ed0fc4d75d4843e183 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Sep 2024 15:54:49 -0700
Subject: [PATCH 2064/2175] Update Base 7.java

---
 Easy/Base 7.java | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/Easy/Base 7.java b/Easy/Base 7.java
index 210d6c39..8da9a029 100644
--- a/Easy/Base 7.java	
+++ b/Easy/Base 7.java	
@@ -1,16 +1,15 @@
 class Solution {
-  public String convertToBase7(int num) {
-    StringBuilder sb = new StringBuilder();
-    char sign = num < 0 ? '-' : ' ';
-    num = Math.abs(num);
-    while (num > 0) {
-      sb.append(num % 7);
-      num /= 7;
+    public String convertToBase7(int num) {
+        StringBuilder sb = new StringBuilder();
+        boolean isNegative = num < 0;
+        num = Math.abs(num);
+        while (num > 0) {
+            sb.append(num % 7);
+            num /= 7;
+        }
+        if (isNegative) {
+            sb.append('-');
+        }
+        return sb.isEmpty() ? "0" : sb.reverse().toString();
     }
-    String representation = sb.length() == 0 ? "0" : sb.reverse().toString();
-    if (sign == '-') {
-      return sign + representation;
-    }
-    return representation;
-  }
 }

From 238c35b45c0b2d09e497e165945b749b9a2d651c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 8 Sep 2024 16:17:19 -0700
Subject: [PATCH 2065/2175] Create Faulty Sensor.java

---
 Easy/Faulty Sensor.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Faulty Sensor.java

diff --git a/Easy/Faulty Sensor.java b/Easy/Faulty Sensor.java
new file mode 100644
index 00000000..dabed6c0
--- /dev/null
+++ b/Easy/Faulty Sensor.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int badSensor(int[] sensor1, int[] sensor2) {
+        int idx = 0;
+        int n = sensor1.length;
+        while (idx < n && sensor1[idx] == sensor2[idx]) {
+            idx++;
+        }
+        while (idx + 1 < n && sensor1[idx] == sensor2[idx + 1] && sensor1[idx + 1] == sensor2[idx]) {
+            idx++;
+        }
+        return idx >= n - 1 ? -1 : sensor1[idx] == sensor2[idx + 1] ? 1 : 2;
+    }
+}

From fe13960db86695574eb4afdbd214fad5bbc9acba Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 9 Sep 2024 08:38:15 -0700
Subject: [PATCH 2066/2175] Update Palindrome Partitioning.java

---
 Medium/Palindrome Partitioning.java | 40 ++++++++++++++++-------------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/Medium/Palindrome Partitioning.java b/Medium/Palindrome Partitioning.java
index 1171f009..de89ed16 100644
--- a/Medium/Palindrome Partitioning.java	
+++ b/Medium/Palindrome Partitioning.java	
@@ -1,27 +1,31 @@
 class Solution {
-    public List<List<String>> partition(String a) {
-        List<List<String>> ans = new ArrayList<>();
-        helper(ans, new ArrayList<String>(), a, 0);
-        return ans;
+    public List<List<String>> partition(String s) {
+        List<List<String>> result = new ArrayList<>();
+        backtrack(result, new ArrayList<>(), s, 0);
+        return result;
     }
- 
-    private void helper(List<List<String>> ans, List<String> temp, String a, int idx) {
-        if (idx == a.length()) {
-            ans.add(new ArrayList<>(temp));
+
+    private void backtrack(List<List<String>> result, List<String> currentList,
+                           String s, int idx) {
+        if (idx == s.length()) {
+            result.add(new ArrayList<>(currentList));
             return;
         }
-        for (int i=idx; i<a.length(); i++) {
-            String sb = a.substring(idx, i+1);
- 
-            if (isPalindrome(sb)) {
-                temp.add(sb);
-                helper(ans, temp, a, i+1);
-                temp.remove(temp.size()-1);
+        for (int i = idx; i < s.length(); i++) {
+            if (isPalindrome(s, idx, i)) {
+                currentList.add(s.substring(idx, i + 1));
+                backtrack(result, currentList, s, i + 1);
+                currentList.removeLast();
             }
         }
     }
- 
-    private boolean isPalindrome(String s) {
-        return new StringBuilder(s).reverse().toString().equals(s);
+
+    private boolean isPalindrome(String s, int startIdx, int endIdx) {
+        while (startIdx < endIdx) {
+            if (s.charAt(startIdx++) != s.charAt(endIdx--)) {
+                return false;
+            }
+        }
+        return true;
     }
 }

From 76879286a3f180f54da092d0425dd8377e9d3eac Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 9 Sep 2024 08:48:50 -0700
Subject: [PATCH 2067/2175] Update Largest BST Subtree.java

---
 Medium/Largest BST Subtree.java | 52 ++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 27 deletions(-)

diff --git a/Medium/Largest BST Subtree.java b/Medium/Largest BST Subtree.java
index 45c83c6f..18ddfeaf 100644
--- a/Medium/Largest BST Subtree.java	
+++ b/Medium/Largest BST Subtree.java	
@@ -4,43 +4,41 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
     public int largestBSTSubtree(TreeNode root) {
-        return largestBSTSubtreeHelper(root);
-    }
-    
-    private int largestBSTSubtreeHelper(TreeNode root) {
-        if (isBST(root)) {
-            return getNodeCount(root);
-        }
-        
-        return Math.max(-1, Math.max(largestBSTSubtreeHelper(root.left), largestBSTSubtreeHelper(root.right)));
-    }
-    
-    private boolean isBST(TreeNode root) {
-        return isBSTHelper(root, Integer.MAX_VALUE, Integer.MIN_VALUE);
-    }
-    
-    private boolean isBSTHelper(TreeNode root, int max, int min) {
         if (root == null) {
-            return true;
+            return 0;
         }
-        
-        if (root.val >= max || root.val <= min) {
-            return false;
+        int[] isBstResult = isBst(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
+        if (isBstResult[0] == 1) {
+            return isBstResult[1];
         }
-        
-        return isBSTHelper(root.left, root.val, min) && isBSTHelper(root.right, max, root.val);
+        return Math.max(largestBSTSubtree(root.left), largestBSTSubtree(root.right));
     }
 
-    private int getNodeCount(TreeNode root) {
+    private int[] isBst(TreeNode root, int minValue, int maxValue) {
         if (root == null) {
-            return 0;
+            return new int[]{1, 0};
+        }
+        int[] result = new int[2];
+        if (!(root.val > minValue && root.val < maxValue)) {
+            return result;
+        }
+        int[] leftIsBst = isBst(root.left, minValue, root.val);
+        int[] rightIsBst = isBst(root.right, root.val, maxValue);
+        if (leftIsBst[0] == 1 && rightIsBst[0] == 1) {
+            result[0] = 1;
+            result[1] = 1 + leftIsBst[1] + rightIsBst[1];
         }
-        
-        return 1 + getNodeCount(root.left) + getNodeCount(root.right);
+        return result;
     }
 }

From ad5efe48ef18c914dfc941fd0e201aa6da5e0452 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 9 Sep 2024 09:03:48 -0700
Subject: [PATCH 2068/2175] Update One Edit Distance.java

---
 Medium/One Edit Distance.java | 59 ++++++++++++++---------------------
 1 file changed, 24 insertions(+), 35 deletions(-)

diff --git a/Medium/One Edit Distance.java b/Medium/One Edit Distance.java
index dc32eede..662a41d1 100644
--- a/Medium/One Edit Distance.java	
+++ b/Medium/One Edit Distance.java	
@@ -1,39 +1,28 @@
 class Solution {
-  public boolean isOneEditDistance(String s, String t) {
-    int lengthDiff = Math.abs(s.length() - t.length());
-    if (s.equals(t) || lengthDiff > 1) {
-      return false;
-    }
-    if (s.length() == 0 || t.length() == 0) {
-      return true;
-    }
-    int idxOne = 0;
-    int idxTwo = 0;
-    boolean changeDone = false;
-    while (idxOne < s.length() && idxTwo < t.length()) {
-      if (s.charAt(idxOne) == t.charAt(idxTwo)) {
-        idxOne++;
-        idxTwo++;
-        continue;
-      }
-      if (changeDone) {
-        return false;
-      }
-      if (lengthDiff != 0) {
-        if (s.length() > t.length()) {
-          idxOne++;
-        } else {
-          idxTwo++;
+    public boolean isOneEditDistance(String s, String t) {
+        int diff = Math.abs(s.length() - t.length());
+        if (s.equals(t) || diff > 1) {
+            return false;
         }
-      } else {
-        idxOne++;
-        idxTwo++;
-      }
-      changeDone = true;
-    }
-    if (changeDone && (idxOne != s.length() || idxTwo != t.length())) {
-      return false;
+        int idx = 0;
+        while (idx < s.length() && idx < t.length()) {
+            if (s.charAt(idx) != t.charAt(idx)) {
+                // Replace character
+                if (s.substring(idx + 1).equals(t.substring(idx + 1))) {
+                    return true;
+                }
+                // Delete 1 character from s
+                if (s.substring(idx + 1).equals(t.substring(idx))) {
+                    return true;
+                }
+                // Delete 1 character from t
+                if (s.substring(idx).equals(t.substring(idx + 1))) {
+                    return true;
+                }
+                return false;
+            }
+            idx++;
+        }
+        return true;
     }
-    return true;
-  }
 }

From c968c70d73ca733683e6f14aaa54d4513531e7ca Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 9 Sep 2024 17:47:51 -0700
Subject: [PATCH 2069/2175] Create Spiral Matrix IV.java

---
 Medium/Spiral Matrix IV.java | 45 ++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 Medium/Spiral Matrix IV.java

diff --git a/Medium/Spiral Matrix IV.java b/Medium/Spiral Matrix IV.java
new file mode 100644
index 00000000..5136b493
--- /dev/null
+++ b/Medium/Spiral Matrix IV.java	
@@ -0,0 +1,45 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public int[][] spiralMatrix(int m, int n, ListNode head) {
+        int[][] result = new int[m][n];
+        for (int i = 0; i < m; i++) {
+            Arrays.fill(result[i], -1);
+        }
+        int topRow = 0;
+        int bottomRow = m - 1;
+        int leftColumn = 0;
+        int rightColumn = n - 1;
+        while (head != null) {
+            for (int col = leftColumn; col <= rightColumn && head != null; col++) {
+                result[topRow][col] = head.val;
+                head = head.next;
+            }
+            topRow++;
+            for (int row = topRow; row <= bottomRow && head != null; row++) {
+                result[row][rightColumn] = head.val;
+                head = head.next;
+            }
+            rightColumn--;
+            for (int col = rightColumn; col >= leftColumn && head != null; col--) {
+                result[bottomRow][col] = head.val;
+                head = head.next;
+            }
+            bottomRow--;
+            for (int row = bottomRow; row >= topRow && head != null; row--) {
+                result[row][leftColumn] = head.val;
+                head = head.next;
+            }
+            leftColumn++;
+        }
+        return result;
+    }
+}

From aebf179f19b50136a7d8e2738a5ced9de4a9a22f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 10 Sep 2024 07:33:58 -0700
Subject: [PATCH 2070/2175] Update Shuffle String.java

---
 Easy/Shuffle String.java | 28 +++++++---------------------
 1 file changed, 7 insertions(+), 21 deletions(-)

diff --git a/Easy/Shuffle String.java b/Easy/Shuffle String.java
index 10340050..f38bf1c2 100644
--- a/Easy/Shuffle String.java	
+++ b/Easy/Shuffle String.java	
@@ -1,24 +1,10 @@
 class Solution {
-  public String restoreString(String s, int[] indices) {
-    char[] letters = s.toCharArray();
-    for (int i = 0; i < indices.length; i++) {
-      while (indices[i] != i) {
-        swapLetter(letters, i, indices[i]);
-        swapIndex(indices, i, indices[i]); 
-      }
+    public String restoreString(String s, int[] indices) {
+        char[] result = new char[s.length()];
+        for (int i = 0; i < s.length(); i++) {
+            int index = indices[i];
+            result[index] = s.charAt(i);
+        }
+        return String.valueOf(result);
     }
-    return String.valueOf(letters);
-  }
-
-  private void swapLetter(char[] arr, int idxOne, int idxTwo) {
-    char temp = arr[idxOne];
-    arr[idxOne] = arr[idxTwo];
-    arr[idxTwo] = temp;
-  }
-
-  private void swapIndex(int[] arr, int idxOne, int idxTwo) {
-    int temp = arr[idxOne];
-    arr[idxOne] = arr[idxTwo];
-    arr[idxTwo] = temp;
-  }
 }

From 94209cf76f7ab258a49eebe18c04e38ad76cf345 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 10 Sep 2024 07:34:47 -0700
Subject: [PATCH 2071/2175] Update Minimum Time Visiting All Points.java

---
 Easy/Minimum Time Visiting All Points.java | 24 +++++++++++++---------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/Easy/Minimum Time Visiting All Points.java b/Easy/Minimum Time Visiting All Points.java
index 774ac97c..ee1a85b1 100644
--- a/Easy/Minimum Time Visiting All Points.java	
+++ b/Easy/Minimum Time Visiting All Points.java	
@@ -1,13 +1,17 @@
 class Solution {
-  public int minTimeToVisitAllPoints(int[][] points) {
-    int time = 0;
-    for (int i = 1; i < points.length; i++) {
-      int[] prevPoint = points[i - 1];
-      int[] currPoint = points[i];
-      time += Math.max(
-        Math.abs(prevPoint[0] - currPoint[0]), Math.abs(prevPoint[1] - currPoint[1])
-      );
+    public int minTimeToVisitAllPoints(int[][] points) {
+        int time = 0;
+        int idx = 0;
+        while (idx < points.length - 1) {
+            time += calculateTime(points[idx], points[idx + 1]);
+            idx++;
+        }
+        return time;
+    }
+    
+    private static int calculateTime(int[] p1, int[] p2) {
+        int x = Math.abs(p1[0] - p2[0]);
+        int y = Math.abs(p1[1] - p2[1]);
+        return Math.max(x, y);
     }
-    return time;
-  }
 }

From c8457b18c67c6944a3fd05e0266e5b9e2f66091c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 10 Sep 2024 11:02:34 -0700
Subject: [PATCH 2072/2175] Update Reverse Vowels of a String.java

---
 Easy/Reverse Vowels of a String.java | 42 ++++++++++++++--------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/Easy/Reverse Vowels of a String.java b/Easy/Reverse Vowels of a String.java
index c1ea0294..ea10d13c 100644
--- a/Easy/Reverse Vowels of a String.java	
+++ b/Easy/Reverse Vowels of a String.java	
@@ -1,24 +1,24 @@
 class Solution {
-  public String reverseVowels(String s) {
-    int left = 0;
-    int right = s.length() - 1;
-    String vowels = "aeiouAEIOU";
-    char[] chars = s.toCharArray();
-    while (left < right) {
-      int vowelIndexLeft = vowels.indexOf(chars[left]);
-      int vowelIndexRight = vowels.indexOf(chars[right]);
-      if (vowelIndexLeft != -1 && vowelIndexRight != -1) {
-        char temp = chars[left];
-        chars[left++] = chars[right];
-        chars[right--] = temp;
-      }
-      else if (vowelIndexRight == -1) {
-        right--;
-      }
-      else {
-        left++;
-      }
+    
+    private static final Set<Character> VOWELS = Set.of('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U');
+    
+    public String reverseVowels(String s) {
+        int left = 0;
+        int right = s.length() - 1;
+        char[] chars = s.toCharArray();
+        while (left <= right) {
+            if (VOWELS.contains(chars[left]) && VOWELS.contains(chars[right])) {
+                char temp = chars[left];
+                chars[left] = chars[right];
+                chars[right] = temp;
+                left++;
+                right--;
+            } else if (!VOWELS.contains(chars[left])) {
+                left++;
+            } else if (!VOWELS.contains(chars[right])) {
+                right--;
+            }
+        }
+        return String.valueOf(chars);
     }
-    return String.valueOf(chars);
-  }
 }

From f029595755aa34a81caae72c31ad1a629cfd9fda Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 12 Sep 2024 08:30:42 -0700
Subject: [PATCH 2073/2175] Update Maximum Size Subarray Sum Equals k.java

---
 .../Maximum Size Subarray Sum Equals k.java   | 29 +++++++++----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/Medium/Maximum Size Subarray Sum Equals k.java b/Medium/Maximum Size Subarray Sum Equals k.java
index 97d37973..dce7007a 100644
--- a/Medium/Maximum Size Subarray Sum Equals k.java	
+++ b/Medium/Maximum Size Subarray Sum Equals k.java	
@@ -1,18 +1,17 @@
 class Solution {
-  public int maxSubArrayLen(int[] nums, int k) {
-    Map<Integer, Integer> map = new HashMap<>();
-    int res = 0;
-    int sum = 0;
-    for (int i = 0; i < nums.length; i++) {
-      sum += nums[i];
-      if (sum == k) {
-        res = i + 1;
-      }
-      else if (map.containsKey(sum - k)) {
-        res = Math.max(res, i - map.get(sum - k));
-      }
-      map.putIfAbsent(sum, i);
+    public int maxSubArrayLen(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int prefixSum = 0;
+        int max = 0;
+        for (int i = 0; i < nums.length; i++) {
+            prefixSum += nums[i];
+            if (prefixSum == k) {
+                max = i + 1;
+            } else if (map.containsKey(prefixSum - k)) {
+                max = Math.max(max, i - map.get(prefixSum - k));
+            }
+            map.putIfAbsent(prefixSum, i);
+        }
+        return max;
     }
-    return res;
-  }
 }

From 08ae7d68bdaea6e4d8a1141b5d2a7574e3c47cdb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 13 Sep 2024 09:12:25 -0700
Subject: [PATCH 2074/2175] Create XOR Queries of a Subarray.java

---
 Medium/XOR Queries of a Subarray.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/XOR Queries of a Subarray.java

diff --git a/Medium/XOR Queries of a Subarray.java b/Medium/XOR Queries of a Subarray.java
new file mode 100644
index 00000000..0bdfc9ca
--- /dev/null
+++ b/Medium/XOR Queries of a Subarray.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int[] xorQueries(int[] arr, int[][] queries) {
+        int n = arr.length;
+        int[] prefixXors = new int[n];
+        int xor = 0;
+        for (int i = 0; i < n; i++) {
+            xor = xor ^ arr[i];
+            prefixXors[i] = xor;
+        }
+        n = queries.length;
+        int[] result = new int[n];
+        for (int i = 0; i < n; i++) {
+            int[] query = queries[i];
+            int left = query[0];
+            int right = query[1];
+            int xorResult = prefixXors[right];
+            if (left != 0) {
+                xorResult = xorResult ^ prefixXors[left - 1];
+            }
+            result[i] = xorResult;
+        }
+        return result;
+    }
+}

From ec93192b5b6d0d395679043110bef3b3df155d43 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 14 Sep 2024 10:33:16 -0700
Subject: [PATCH 2075/2175] Create Longest Subarray With Maximum Bitwise
 AND.java

---
 ...est Subarray With Maximum Bitwise AND.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Longest Subarray With Maximum Bitwise AND.java

diff --git a/Medium/Longest Subarray With Maximum Bitwise AND.java b/Medium/Longest Subarray With Maximum Bitwise AND.java
new file mode 100644
index 00000000..63c1ca55
--- /dev/null
+++ b/Medium/Longest Subarray With Maximum Bitwise AND.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int result = 0;
+        int max = 0;
+        int count = 0;
+        for (int num : nums) {
+            if (max < num) {
+                max = num;
+                result = count = 0;
+            }
+            if (max == num) {
+                count++;
+            } else {
+                count = 0;
+            }
+            result = Math.max(result, count);
+        }
+        return result;
+    }
+}

From 4e3321b796755556dbcb22ca263ca558b2fbf626 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 15 Sep 2024 08:56:53 -0700
Subject: [PATCH 2076/2175] Create Find the Longest Substring Containing Vowels
 in Even Counts.java

---
 ...ring Containing Vowels in Even Counts.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Find the Longest Substring Containing Vowels in Even Counts.java

diff --git a/Medium/Find the Longest Substring Containing Vowels in Even Counts.java b/Medium/Find the Longest Substring Containing Vowels in Even Counts.java
new file mode 100644
index 00000000..66e33ef9
--- /dev/null
+++ b/Medium/Find the Longest Substring Containing Vowels in Even Counts.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int findTheLongestSubstring(String s) {
+        int prefixXor = 0;
+        char[] frequency = new char[26];
+        frequency['a' - 'a'] = 1;
+        frequency['e' - 'a'] = 2;
+        frequency['i' - 'a'] = 4;
+        frequency['o' - 'a'] = 8;
+        frequency['u' - 'a'] = 16;
+        int[] indexMap = new int[32];
+        Arrays.fill(indexMap, -1);
+        int result = 0;
+        for (int i = 0; i < s.length(); i++) {
+            prefixXor ^= frequency[s.charAt(i) - 'a'];
+            if (indexMap[prefixXor] == -1 && prefixXor != 0) {
+                indexMap[prefixXor] = i;
+            }
+            result = Math.max(result, i - indexMap[prefixXor]);
+        }
+        return result;
+    }
+}

From f6c5fbcf06e1cc589de81072d148ee5933d7b72d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 15 Sep 2024 21:30:25 -0700
Subject: [PATCH 2077/2175] Create Find Indices of Stable Mountains.java

---
 Easy/Find Indices of Stable Mountains.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Find Indices of Stable Mountains.java

diff --git a/Easy/Find Indices of Stable Mountains.java b/Easy/Find Indices of Stable Mountains.java
new file mode 100644
index 00000000..3e0fbd79
--- /dev/null
+++ b/Easy/Find Indices of Stable Mountains.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public List<Integer> stableMountains(int[] height, int threshold) {
+        List<Integer> result = new ArrayList<>();
+        for (int i = 1; i < height.length; i++) {
+            if (height[i - 1] > threshold) {
+                result.add(i);
+            }
+        }
+        return result;
+    }
+}

From b10f51abbd6353d0469b733252bc3c00a0089f75 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 17 Sep 2024 06:34:56 -0700
Subject: [PATCH 2078/2175] Create Smallest Common Region.java

---
 Medium/Smallest Common Region.java | 32 ++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Medium/Smallest Common Region.java

diff --git a/Medium/Smallest Common Region.java b/Medium/Smallest Common Region.java
new file mode 100644
index 00000000..4d8ce894
--- /dev/null
+++ b/Medium/Smallest Common Region.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public String findSmallestRegion(List<List<String>> regions, String region1, String region2) {
+        Map<String, String> regionToParentMap = new HashMap<>();
+        for (List<String> region : regions) {
+            String parent = region.getFirst();
+            for (int i = 1; i < region.size(); i++) {
+                regionToParentMap.put(region.get(i), parent);
+            }
+        }
+        List<String> pathOne = trace(region1, regionToParentMap);
+        List<String> pathTwo = trace(region2, regionToParentMap);
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < pathOne.size() && idxTwo < pathTwo.size() && pathOne.get(idxOne).equals(pathTwo.get(idxTwo))) {
+            idxOne++;
+            idxTwo++;
+        }
+        return pathOne.get(idxOne - 1);
+    }
+
+    private List<String> trace(String region, Map<String, String> regionToParentMap) {
+        List<String> path = new ArrayList<>();
+        path.add(region);
+        while (regionToParentMap.containsKey(region)) {
+            String parent = regionToParentMap.get(region);
+            path.add(parent);
+            region = parent;
+        }
+        Collections.reverse(path);
+        return path;
+    }
+}

From 20d5bc1645f2112c99ab9296f8ae50b4542e946c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 19 Sep 2024 06:32:29 -0700
Subject: [PATCH 2079/2175] Create Different Ways to Add Parentheses.java

---
 Medium/Different Ways to Add Parentheses.java | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Medium/Different Ways to Add Parentheses.java

diff --git a/Medium/Different Ways to Add Parentheses.java b/Medium/Different Ways to Add Parentheses.java
new file mode 100644
index 00000000..706fcf6c
--- /dev/null
+++ b/Medium/Different Ways to Add Parentheses.java	
@@ -0,0 +1,42 @@
+class Solution {
+    public List<Integer> diffWaysToCompute(String expression) {
+        List<Integer> result = new ArrayList<>();
+        if (expression.length() == 0) {
+            return result;
+        }
+        if (expression.length() == 1) {
+            result.add(Integer.parseInt(expression));
+            return result;
+        }
+        if (expression.length() == 2 && Character.isDigit(expression.charAt(0))) {
+            result.add(Integer.parseInt(expression));
+            return result;
+        }
+        for (int i = 0; i < expression.length(); i++) {
+            char c = expression.charAt(i);
+            if (Character.isDigit(c)) {
+                continue;
+            }
+            List<Integer> leftResult = diffWaysToCompute(expression.substring(0, i));
+            List<Integer> rightResult = diffWaysToCompute(expression.substring(i + 1));
+            for (int leftVal : leftResult) {
+                for (int rightVal : rightResult) {
+                    int value = 0;
+                    switch(c) {
+                        case '+':
+                            value = leftVal + rightVal;
+                            break;
+                        case '-':
+                            value = leftVal - rightVal;
+                            break;
+                        case '*':
+                            value = leftVal * rightVal;
+                            break;
+                    }
+                    result.add(value);
+                }
+            }
+        }
+        return result;
+    }
+}

From 33cbd03bdbc238fdfa2ba6949249af8d503c64f6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 20 Sep 2024 06:58:05 -0700
Subject: [PATCH 2080/2175] Create Shortest Palindrome.java

---
 Hard/Shortest Palindrome.java | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Hard/Shortest Palindrome.java

diff --git a/Hard/Shortest Palindrome.java b/Hard/Shortest Palindrome.java
new file mode 100644
index 00000000..3ff38e40
--- /dev/null
+++ b/Hard/Shortest Palindrome.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public String shortestPalindrome(String s) {
+        int n = s.length();
+        if (n == 0) {
+            return s;
+        }
+        int left = 0;
+        for (int right = n - 1; right >= 0; right--) {
+            if (s.charAt(right) == s.charAt(left)) {
+                left++;
+            }
+        }
+        if (left == n) {
+            return s;
+        }
+        String nonPalindromeSuffix = s.substring(left);
+        StringBuilder reverseSuffix = new StringBuilder(nonPalindromeSuffix).reverse();
+        return reverseSuffix
+            .append(shortestPalindrome(s.substring(0, left)))
+            .append(nonPalindromeSuffix)
+            .toString();
+    }
+}

From c97bb9f4059847b67a7f53ca9fb9ee11ff385ab1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 20 Sep 2024 17:44:54 -0700
Subject: [PATCH 2081/2175] Update Lexicographical Numbers.java

---
 Medium/Lexicographical Numbers.java | 31 ++++++++++++++---------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/Medium/Lexicographical Numbers.java b/Medium/Lexicographical Numbers.java
index c0ccab5e..4476017b 100644
--- a/Medium/Lexicographical Numbers.java	
+++ b/Medium/Lexicographical Numbers.java	
@@ -1,19 +1,18 @@
 class Solution {
-  public List<Integer> lexicalOrder(int n) {
-    List<Integer> result = new ArrayList<>();
-    for (int i = 1; i < 10; i++) {
-      dfs(i, n, result);
+    public List<Integer> lexicalOrder(int n) {
+        List<Integer> result = new ArrayList<>();
+        int curr = 1;
+        for (int i = 0; i < n; i++) {
+            result.add(curr);
+            if (curr * 10 <= n) {
+                curr *= 10;
+            } else {
+                while (curr % 10 == 9 || curr == n) {
+                    curr /= 10;
+                }
+                curr++;
+            }
+        }
+        return result;
     }
-    return result;
-  }
-  
-  private void dfs(int curr, int n, List<Integer> result) {
-    if (curr > n) {
-      return;
-    }
-    result.add(curr);
-    for (int i = 0; i < 10; i++) {
-      dfs(10 * curr + i, n, result);
-    }
-  }
 }

From 68486f5d8e372ceeed62ff36dedbdfa95799ee11 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 21 Sep 2024 07:13:55 -0700
Subject: [PATCH 2082/2175] Update Sliding Window Median.java

---
 Hard/Sliding Window Median.java | 117 ++++++++++++++------------------
 1 file changed, 52 insertions(+), 65 deletions(-)

diff --git a/Hard/Sliding Window Median.java b/Hard/Sliding Window Median.java
index 944af371..e37c289d 100644
--- a/Hard/Sliding Window Median.java	
+++ b/Hard/Sliding Window Median.java	
@@ -1,72 +1,59 @@
 class Solution {
-    List<Long> list;
-    double[] ans;
-    boolean isEven;
-
-    public double[] medianSlidingWindow(int[] nums, int k) {
-        list = new ArrayList<>();
-        ans = new double[nums.length - k + 1];
-        isEven = k % 2 == 0;
-
-        for (int i=0; i<k; i++) {
-            list.add((long) nums[i]);
-        }
-
-        Collections.sort(list);
-        int idx = 0;
-        ans[idx++] = getMedian();
-
-        for (int i=k; i<nums.length; i++) {
-            removeElement(nums[idx - 1]);
-            int tempIdx = getBinarySearchIdx(nums[i]);
-            list.add(tempIdx, (long) nums[i]);
-
-            ans[idx++] = getMedian();
-        }
-
-        return ans;
-    }
-
-    private int getBinarySearchIdx(int num) {
-        if (list.size() == 0 || num < list.get(0)) {
-            return 0;
-        }
-        if (num > list.get(list.size() - 1)) {
-            return list.size();
-        }
-
-        int start = 0;
-        int end = list.size();
-
-        while (start < end) {
-            int mid = (start + end) / 2;
-
-            if (list.get(mid) < num) {
-                start = mid + 1;
-            }
-            else {
-                end = mid;
+    public double[] medianSlidingWindow(int[] nums, int windowSize) {
+        double[] medians = new double[nums.length - windowSize + 1];
+        Map<Integer, Integer> delayedRemovals = new HashMap<>();
+        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());  
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();                          
+        int currentIndex = 0;
+        while (currentIndex < windowSize) {
+            maxHeap.add(nums[currentIndex++]);
+        }
+        for (int j = 0; j < windowSize / 2; j++) {
+            minHeap.add(maxHeap.poll());
+        }
+        int medianIndex = 0;
+        while (true) {
+            if (windowSize % 2 == 1) {
+                medians[medianIndex++] = maxHeap.peek();
+            } else {
+                medians[medianIndex++] = ((double) maxHeap.peek() + (double) minHeap.peek()) / 2.0;
             }
-        }
-
-        return end;
-    }
-
-    private void removeElement(int num) {
-        for (int i=0; i<list.size(); i++) {
-            if (list.get(i) == num) {
-                list.remove(i);
+            if (currentIndex >= nums.length) {
                 break;
             }
+            int outNum = nums[currentIndex - windowSize];  
+            int inNum = nums[currentIndex++];             
+            int balance = 0;                        
+            // Handle outgoing number
+            balance += (outNum <= maxHeap.peek() ? -1 : 1);
+            delayedRemovals.put(outNum, delayedRemovals.getOrDefault(outNum, 0) + 1);
+            // Handle incoming number
+            if (!maxHeap.isEmpty() && inNum <= maxHeap.peek()) {
+                balance++;
+                maxHeap.add(inNum);
+            } else {
+                balance--;
+                minHeap.add(inNum);
+            }
+            // Rebalance heaps
+            if (balance < 0) {
+                maxHeap.add(minHeap.poll());
+                balance++;
+            }
+            if (balance > 0) {
+                minHeap.add(maxHeap.poll());
+                balance--;
+            }
+            // Remove invalid numbers from the top of the heaps
+            while (delayedRemovals.getOrDefault(maxHeap.peek(), 0) > 0) {
+                delayedRemovals.put(maxHeap.peek(), delayedRemovals.get(maxHeap.peek()) - 1);
+                maxHeap.poll();
+            }
+            while (!minHeap.isEmpty() && delayedRemovals.getOrDefault(minHeap.peek(), 0) > 0) {
+                delayedRemovals.put(minHeap.peek(), delayedRemovals.get(minHeap.peek()) - 1);
+                minHeap.poll();
+            }
         }
-    }
-
-    private double getMedian() {
-        if (isEven) {
-            return (double) (list.get(list.size()/2) + list.get(list.size()/2 - 1)) / 2;
-        }
-        else {
-            return (double) list.get(list.size()/2);
-        }
+        return medians;
     }
 }

From fe09ade65cbd4a3b05410a7924619253f79d5358 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 21 Sep 2024 07:30:10 -0700
Subject: [PATCH 2083/2175] Create Most Beautiful Item for Each Query.java

---
 Medium/Most Beautiful Item for Each Query.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Most Beautiful Item for Each Query.java

diff --git a/Medium/Most Beautiful Item for Each Query.java b/Medium/Most Beautiful Item for Each Query.java
new file mode 100644
index 00000000..5d2f75db
--- /dev/null
+++ b/Medium/Most Beautiful Item for Each Query.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] maximumBeauty(int[][] items, int[] queries) {
+        Arrays.sort(items, (a, b) -> (a[0] - b[0]));
+        TreeMap<Integer, Integer> map = new TreeMap<>();
+        map.put(0, 0);
+        int currMax = 0;
+        for (int[] item : items) {
+            currMax = Math.max(currMax, item[1]);
+            map.put(item[0], currMax);
+        }
+        int[] result = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            result[i] = map.floorEntry(queries[i]).getValue();
+        }
+        return result;
+    }
+}

From 049b2483f54ff74ed04e872c54e272529c99ca8d Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 22 Sep 2024 08:29:37 -0700
Subject: [PATCH 2084/2175] Update Longest Word With All Prefixes.java

---
 Medium/Longest Word With All Prefixes.java | 94 ++++++++++++----------
 1 file changed, 50 insertions(+), 44 deletions(-)

diff --git a/Medium/Longest Word With All Prefixes.java b/Medium/Longest Word With All Prefixes.java
index 567aea3a..a2a69a0f 100644
--- a/Medium/Longest Word With All Prefixes.java	
+++ b/Medium/Longest Word With All Prefixes.java	
@@ -1,53 +1,59 @@
 class Solution {
-  public String longestWord(String[] words) {
-    TrieNode root = new TrieNode();
-    root.isWord = true;
-    Map<Integer, PriorityQueue<String>> map = new TreeMap<>((o1, o2) -> o2 - o1);
-    for (String word : words) {
-      addToTrie(word, root);
-      map.computeIfAbsent(word.length(), k -> new PriorityQueue<>(String::compareTo)).add(word);
-    }
-    for (Integer key : map.keySet()) {
-      PriorityQueue<String> priorityQueue = map.get(key);
-      while (!priorityQueue.isEmpty()) {
-        String candidateWord = priorityQueue.poll();
-        if (wordContainAllPrefixes(candidateWord, root)) {
-          return candidateWord;
+    public String longestWord(String[] words) {
+        TrieNode root = new TrieNode();
+        for (String word : words) {
+            root.insert(word);
+        }
+        String longestValidWord = "";
+        for (String word : words) {
+            if (root.hasAllPrefixes(word)) {
+                if (word.length() > longestValidWord.length() || 
+                    (word.length() == longestValidWord.length() && word.compareTo(longestValidWord) < 0)) {
+                    longestValidWord = word;
+                }
+            }
         }
-      }
+        return longestValidWord;
     }
-    return "";
-  }
 
-  private boolean wordContainAllPrefixes(String word, TrieNode root) {
-    TrieNode curr = root;
-    for (int i = 0; i < word.length(); i++) {
-      if (!curr.isWord) {
-        return false;
-      }
-      curr = curr.children.get(word.charAt(i));
-    }
-    return curr.isWord;
-  }
+    static class TrieNode {
+        private final Map<Character, TrieNode> children;
+        private boolean isWord;
 
-  private void addToTrie(String word, TrieNode root) {
-    TrieNode curr = root;
-    for (int i = 0; i < word.length(); i++) {
-      if (!curr.children.containsKey(word.charAt(i))) {
-        curr.children.put(word.charAt(i), new TrieNode());
-      }
-      curr = curr.children.get(word.charAt(i));
-    }
-    curr.isWord = true;
-  }
+        public TrieNode() {
+            this.children = new HashMap<>();
+        }
 
-  private static class TrieNode {
-    Map<Character, TrieNode> children;
-    boolean isWord;
+        public void insert(String word) {
+            TrieNode curr = this;
+            for (char c : word.toCharArray()) {
+                curr = curr.getOrCreateChild(c);
+            }
+            curr.isWord = true;
+        }
+
+        public boolean hasAllPrefixes(String word) {
+            TrieNode curr = this;
+            for (char c : word.toCharArray()) {
+                TrieNode child = curr.children.getOrDefault(c, null);
+                if (child == null) {
+                    return false;
+                }       
+                if (!child.isWord) {
+                    return false;
+                }
+                curr = child;
+            }
+            return true;
+        }
 
-    public TrieNode() {
-      this.children = new HashMap<>();
-      this.isWord = false;
+        private TrieNode getOrCreateChild(char c) {
+            if (children.containsKey(c)) {
+                return children.get(c);
+            }
+            TrieNode node = new TrieNode();
+            children.put(c, node);
+            return node;
+        }
     }
-  }
 }

From f12e321cfd48e32055dcbc0036907dfa6f46b4e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 22 Sep 2024 10:21:41 -0700
Subject: [PATCH 2085/2175] Update Binary Search Tree Iterator II.java

---
 Medium/Binary Search Tree Iterator II.java | 74 +++++++++++-----------
 1 file changed, 36 insertions(+), 38 deletions(-)

diff --git a/Medium/Binary Search Tree Iterator II.java b/Medium/Binary Search Tree Iterator II.java
index 9f98110c..61ab1d10 100644
--- a/Medium/Binary Search Tree Iterator II.java	
+++ b/Medium/Binary Search Tree Iterator II.java	
@@ -14,49 +14,47 @@
  * }
  */
 class BSTIterator {
-  
-  private Deque<TreeNode> stack;
-  private List<Integer> arr;
-  private TreeNode lastNode;
-  private int pointer;
-  
-  public BSTIterator(TreeNode root) {
-    this.stack = new ArrayDeque();
-    this.arr = new ArrayList<>();
-    this.lastNode = root;
-    this.pointer = -1;
-  }
 
-  public boolean hasNext() {
-    return !this.stack.isEmpty() || lastNode != null || this.pointer < arr.size() - 1;
-  }
+    private final Deque<TreeNode> primary;
+    private final List<Integer> secondary;
+    private int index;
 
-  public int next() {
-    this.pointer++;
-    if (this.pointer == this.arr.size()) {
-      updateStack(lastNode);
-      TreeNode curr = this.stack.pop();
-      lastNode = curr.right;
-      this.arr.add(curr.val);
+    public BSTIterator(TreeNode root) {
+        this.primary = new ArrayDeque<>();
+        this.secondary = new ArrayList<>();
+        this.index = -1;
+        traverse(root);
+    }
+    
+    public boolean hasNext() {
+        return !primary.isEmpty() || index < secondary.size() - 1;
+    }
+    
+    public int next() {
+        index++;
+        if (index == secondary.size()) {
+            TreeNode curr = primary.pop();
+            secondary.add(curr.val);
+            traverse(curr.right);
+        }
+        return secondary.get(index);
+    }
+    
+    public boolean hasPrev() {
+        return index > 0;
+    }
+    
+    public int prev() {
+        index--;
+        return secondary.get(index);
     }
-    return this.arr.get(this.pointer);
-  }
-
-  public boolean hasPrev() {
-    return this.pointer > 0;
-  }
 
-  public int prev() {
-    this.pointer--;
-    return this.arr.get(this.pointer);
-  }
-  
-  private void updateStack(TreeNode node) {
-    while (node != null) {
-      this.stack.push(node);
-      node = node.left;
+    private void traverse(TreeNode root) {
+        while (root != null) {
+            primary.push(root);
+            root = root.left;
+        }
     }
-  }
 }
 
 /**

From 76548263a55db618f5973d3c7a88f49ace92a772 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 22 Sep 2024 15:16:25 -0700
Subject: [PATCH 2086/2175] Create K-th Smallest in Lexicographical Order.java

---
 ...-th Smallest in Lexicographical Order.java | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Hard/K-th Smallest in Lexicographical Order.java

diff --git a/Hard/K-th Smallest in Lexicographical Order.java b/Hard/K-th Smallest in Lexicographical Order.java
new file mode 100644
index 00000000..9063cd56
--- /dev/null
+++ b/Hard/K-th Smallest in Lexicographical Order.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int findKthNumber(int n, int k) {
+        int curr = 1;
+        k--;
+        while (k > 0) {
+            int count = countNumsWithPrefix(n, curr, curr + 1);
+            if (count <= k) {
+                curr++;
+                k -= count;
+            } else {
+                curr *= 10;
+                k--;
+            }
+        }
+        return curr;
+    }
+
+    private int countNumsWithPrefix(int n, long start, long end) {
+        int count = 0;
+        while (start <= n) {
+            count += Math.min(n + 1, end) - start;
+            start *= 10;
+            end *= 10;
+        }
+        return count;
+    }
+}

From 7e4afd555a663578a5662bd8e83459350cd0ccd5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 28 Sep 2024 09:09:04 -0700
Subject: [PATCH 2087/2175] Update Design Circular Deque.java

---
 Medium/Design Circular Deque.java | 154 ++++++++++++++----------------
 1 file changed, 70 insertions(+), 84 deletions(-)

diff --git a/Medium/Design Circular Deque.java b/Medium/Design Circular Deque.java
index 86949d4a..66667ed5 100644
--- a/Medium/Design Circular Deque.java	
+++ b/Medium/Design Circular Deque.java	
@@ -1,104 +1,90 @@
 class MyCircularDeque {
-  
-  private Node head;
-  private Node tail;
-  private int k;
-  private int currSize;
 
-  public MyCircularDeque(int k) {
-    this.k = k;
-    this.currSize = 0;
-    this.head = new Node(-1);
-    this.tail = new Node(-1);
-    this.head.next = this.tail;
-    this.tail.prev = this.head;
-  }
+    private final Node head;
+    private final Node tail;
+    private final int capacity;
+    private int size;
 
-  public boolean insertFront(int value) {
-    if (isFull()) {
-      return false;
+    public MyCircularDeque(int k) {
+        head = new Node(-1);
+        tail = new Node(-1);
+        head.next = tail;
+        tail.prev = head;
+        capacity = k;
+        size = 0;
     }
-    Node node = new Node(value);
-    Node nextToHead = head.next;
-    head.next = node;
-    node.prev = head;
-    node.next = nextToHead;
-    nextToHead.prev = node;
-    currSize++;
-    return true;
-  }
 
-  public boolean insertLast(int value) {
-    if (isFull()) {
-      return false;
+    public boolean insertFront(int value) {
+        if (size == capacity) {
+            return false;
+        }
+        Node node = new Node(value);
+        node.next = head.next;
+        node.prev = head;
+        head.next.prev = node;
+        head.next = node;
+        size++;
+        return true;
     }
-    Node node = new Node(value);
-    Node prevToTail = tail.prev;
-    tail.prev = node;
-    node.next = tail;
-    prevToTail.next = node;
-    node.prev = prevToTail;
-    currSize++;
-    return true;
-  }
 
-  public boolean deleteFront() {
-    if (isEmpty()) {
-      return false;
+    public boolean insertLast(int value) {
+        if (size == capacity) {
+            return false;
+        }
+        Node node = new Node(value);
+        node.prev = tail.prev;
+        node.next = tail;
+        tail.prev.next = node;
+        tail.prev = node;
+        size++;
+        return true;
     }
-    Node toDelete = head.next;
-    deleteNode(toDelete);
-    return true;
-  }
 
-  public boolean deleteLast() {
-    if (isEmpty()) {
-      return false;
+    public boolean deleteFront() {
+        if (size == 0) {
+            return false;
+        }
+        head.next.next.prev = head;
+        head.next = head.next.next;
+        size--;
+        return true;
     }
-    Node toDelete = tail.prev;
-    deleteNode(toDelete);
-    return true;
-  }
 
-  public int getFront() {
-    if (isEmpty()) {
-      return -1;
+    public boolean deleteLast() {
+        if (size == 0) {
+            return false;
+        }
+        tail.prev.prev.next = tail;
+        tail.prev = tail.prev.prev;
+        size--;
+        return true;
     }
-    return head.next.val;
-  }
 
-  public int getRear() {
-    if (isEmpty()) {
-      return -1;
+    public int getFront() {
+        return head.next.value;
     }
-    return tail.prev.val;
-  }
 
-  public boolean isEmpty() {
-    return currSize == 0;
-  }
+    public int getRear() {
+        return tail.prev.value;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public boolean isFull() {
+        return size == capacity;
+    }
+
+    static class Node {
+        int value;
+        Node next;
+        Node prev;
 
-  public boolean isFull() {
-    return currSize == k;
-  }
-  
-  private void deleteNode(Node node) {
-    Node prevToNode = node.prev;
-    Node nextToNode = node.next;
-    prevToNode.next = nextToNode;
-    nextToNode.prev = prevToNode;
-    currSize--;
-  }
-  
-  private static class Node {
-    int val;
-    Node next;
-    Node prev;
-    
-    public Node(int val) {
-      this.val = val;
+        Node(int value) {
+            this.value = value;
+        }
     }
-  }
 }
 
 /**

From 877f164cd5305a15c080c7e0122c092d3abe4eb2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 30 Sep 2024 08:21:33 -0700
Subject: [PATCH 2088/2175] Update Design a Stack With Increment Operation.java

---
 ...sign a Stack With Increment Operation.java | 62 +++++++++----------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/Medium/Design a Stack With Increment Operation.java b/Medium/Design a Stack With Increment Operation.java
index 9164401b..9e4ec3a3 100644
--- a/Medium/Design a Stack With Increment Operation.java	
+++ b/Medium/Design a Stack With Increment Operation.java	
@@ -1,40 +1,40 @@
 class CustomStack {
-  
-  private Stack<Integer> stack;
-  private int[] incrementArray;
-  private int maxSize;
-  
-  public CustomStack(int maxSize) {
-    this.stack = new Stack<>();
-    this.incrementArray = new int[maxSize];
-    this.maxSize = maxSize;
-  }
 
-  public void push(int x) {
-    if (this.stack.size() < this.maxSize) {
-      this.stack.push(x);
-    }
-  }
+    private final int maxSize;
+    private final Stack<Integer> stack;
+    private int[] increment;
 
-  public int pop() {
-    int idx = this.stack.size() - 1;
-    if (idx < 0) {
-      return -1;
+    public CustomStack(int maxSize) {
+        this.maxSize = maxSize;
+        this.stack = new Stack<>();
+        this.increment = new int[maxSize];
     }
-    if (idx > 0) {
-      this.incrementArray[idx - 1] += this.incrementArray[idx];
+    
+    public void push(int x) {
+        if (stack.size() < maxSize) {
+            stack.push(x);
+        }
     }
-    int result = this.stack.pop() + this.incrementArray[idx];
-    this.incrementArray[idx] = 0;
-    return result;
-  }
-
-  public void increment(int k, int val) {
-    int idx = Math.min(k, this.stack.size()) - 1;
-    if (idx >= 0) {
-      this.incrementArray[idx] += val;
+    
+    public int pop() {
+        int idx = stack.size() - 1;
+        if (idx < 0) {
+            return -1;
+        }
+        if (idx > 0) {
+            increment[idx - 1] += increment[idx];
+        }
+        int result = stack.pop() + increment[idx];
+        increment[idx] = 0;
+        return result;
+    }
+    
+    public void increment(int k, int val) {
+        int idx = Math.min(k, stack.size()) - 1;
+        if (idx >= 0) {
+            increment[idx] += val;
+        }
     }
-  }
 }
 
 /**

From a752149a8e834ce931f706737ab398d6e7c57597 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Oct 2024 06:47:24 -0700
Subject: [PATCH 2089/2175] Create Check If Array Pairs Are Divisible by k.java

---
 ...eck If Array Pairs Are Divisible by k.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Check If Array Pairs Are Divisible by k.java

diff --git a/Medium/Check If Array Pairs Are Divisible by k.java b/Medium/Check If Array Pairs Are Divisible by k.java
new file mode 100644
index 00000000..d942915f
--- /dev/null
+++ b/Medium/Check If Array Pairs Are Divisible by k.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public boolean canArrange(int[] arr, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : arr) {
+            int remainder = ((num % k) + k) % k;
+            map.put(remainder, map.getOrDefault(remainder, 0) + 1);
+        }
+        for (int num : arr) {
+            int remainder = ((num % k) + k) % k;
+            if (remainder == 0) {
+                if (map.get(remainder) % 2 == 1) {
+                    return false;
+                }
+            } else if (!map.get(remainder).equals(map.get(k - remainder))) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From 1faa9c843764223e985afa1d6d816b4277f4707c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 1 Oct 2024 17:34:31 -0700
Subject: [PATCH 2090/2175] Update Rank Transform of an Array.java

---
 Easy/Rank Transform of an Array.java | 33 ++++++++++++++--------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/Easy/Rank Transform of an Array.java b/Easy/Rank Transform of an Array.java
index 401c317b..3f9192fd 100644
--- a/Easy/Rank Transform of an Array.java	
+++ b/Easy/Rank Transform of an Array.java	
@@ -1,20 +1,19 @@
 class Solution {
-  public int[] arrayRankTransform(int[] arr) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>();
-    for (int num : arr) {
-      pq.add(num);
+    public int[] arrayRankTransform(int[] arr) {
+        int[] copyArr = Arrays.copyOf(arr, arr.length);
+        Arrays.sort(arr);
+        int rank = 1;
+        Map<Integer, Integer> numToRank = new HashMap<>();
+        for (int num : arr) {
+            if (numToRank.containsKey(num)) {
+                continue;
+            }
+            numToRank.put(num, rank++);
+        }
+        int[] result = new int[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            result[i] = numToRank.get(copyArr[i]);
+        }
+        return result;
     }
-    int rank = 1;
-    Map<Integer, Integer> map = new HashMap<>();
-    while (!pq.isEmpty()) {
-      int removed = pq.poll();
-      if (!map.containsKey(removed)) {
-        map.put(removed, rank++);
-      }
-    }
-    for (int i = 0; i < arr.length; i++) {
-      arr[i] = map.get(arr[i]);
-    }
-    return arr;
-  }
 }

From 914a2fc291a5634d072744e2f57289cea48822da Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Oct 2024 09:50:16 -0700
Subject: [PATCH 2091/2175] Create Make Sum Divisible by P.java

---
 Medium/Make Sum Divisible by P.java | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 Medium/Make Sum Divisible by P.java

diff --git a/Medium/Make Sum Divisible by P.java b/Medium/Make Sum Divisible by P.java
new file mode 100644
index 00000000..ee94817a
--- /dev/null
+++ b/Medium/Make Sum Divisible by P.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int minSubarray(int[] nums, int p) {
+        int n = nums.length;
+        int sum = 0;
+        for (int num : nums) {
+            sum = (sum + num) % p;
+        }
+        int target = sum % p;
+        if (target == 0) {
+            return 0;
+        }
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(0, -1);
+        int currSum = 0;
+        int result = n; 
+        for (int i = 0; i < n; i++) {
+            currSum = (currSum + nums[i]) % p;
+            int needed = (currSum - target + p) % p;
+            if (map.containsKey(needed)) {
+                result = Math.min(result, i - map.get(needed));
+            }
+            map.put(currSum, i);
+        }
+        return result == n ? -1 : result;
+    }
+}

From 650d084e89e1fe0d4ac6452d502fd280787e4f14 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 3 Oct 2024 17:51:53 -0700
Subject: [PATCH 2092/2175] Update Divide Players Into Teams of Equal
 Skill.java

---
 ...ide Players Into Teams of Equal Skill.java | 28 +++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/Medium/Divide Players Into Teams of Equal Skill.java b/Medium/Divide Players Into Teams of Equal Skill.java
index bebcec21..41a5f1f7 100644
--- a/Medium/Divide Players Into Teams of Equal Skill.java	
+++ b/Medium/Divide Players Into Teams of Equal Skill.java	
@@ -1,19 +1,25 @@
 class Solution {
     public long dividePlayers(int[] skill) {
-        Arrays.sort(skill);
+        int n = skill.length;
+        int totalSkill = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int s : skill) {
+            totalSkill += s;
+            map.put(s, map.getOrDefault(s, 0) + 1);
+        }
+        if (totalSkill % (n / 2) != 0) {
+            return -1;
+        }
+        int targetSkill = totalSkill / (n / 2);
         long totalChemistry = 0;
-        int start = 0;
-        int end = skill.length - 1;
-        int totalSkill = skill[start] + skill[end];
-        while (start < end) {
-            int currTotal = skill[start] + skill[end];
-            if (currTotal != totalSkill) {
+        for (int currSkill : map.keySet()) {
+            int partnerSkill = targetSkill - currSkill;
+            int currSkillFreq = map.get(currSkill);
+            if (!map.containsKey(partnerSkill) || currSkillFreq != map.get(partnerSkill)) {
                 return -1;
             }
-            totalChemistry += skill[start] * skill[end];
-            start++;
-            end--;
+            totalChemistry += (long) currSkill * (long) partnerSkill * (long) currSkillFreq;
         }
-        return totalChemistry;
+        return totalChemistry / 2;
     }
 }

From 1c21ef27bee9a434d927ebaab33aa6910a192f2c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 5 Oct 2024 18:26:00 -0700
Subject: [PATCH 2093/2175] Update Sentence Similarity III.java

---
 Medium/Sentence Similarity III.java | 51 +++++++++++++----------------
 1 file changed, 23 insertions(+), 28 deletions(-)

diff --git a/Medium/Sentence Similarity III.java b/Medium/Sentence Similarity III.java
index e85bb024..506dc110 100644
--- a/Medium/Sentence Similarity III.java	
+++ b/Medium/Sentence Similarity III.java	
@@ -1,31 +1,26 @@
 class Solution {
-  public boolean areSentencesSimilar(String sentence1, String sentence2) {
-    return isSimilar(sentence1.split(" "), sentence2.split(" ")) || isSimilar(sentence2.split(" "),
-        sentence1.split(" "));
-  }
-
-  private boolean isSimilar(String[] matcher, String[] target) {
-    int targetStartIdx = 0;
-    int matcherCurrentIdx = 0;
-    while (targetStartIdx < target.length && matcherCurrentIdx < matcher.length) {
-      if (!matcher[matcherCurrentIdx].equals(target[targetStartIdx])) {
-        break;
-      }
-      targetStartIdx++;
-      matcherCurrentIdx++;
+    public boolean areSentencesSimilar(String sentence1, String sentence2) {
+        int idxOneStart = 0;
+        int idxTwoStart = 0;
+        String[] wordsOne = sentence1.split("\\s+"); 
+        String[] wordsTwo = sentence2.split("\\s+"); 
+        while (idxOneStart < wordsOne.length && idxOneStart < wordsTwo.length && wordsOne[idxOneStart].equals(wordsTwo[idxTwoStart])) {
+            idxOneStart++;
+            idxTwoStart++;
+        }
+        boolean startFound = idxOneStart > 0;
+        if (idxOneStart == wordsOne.length && idxTwoStart == wordsTwo.length) {
+            return true;
+        }
+        int idxOneEnd = wordsOne.length - 1;
+        int idxTwoEnd = wordsTwo.length - 1;
+        while (idxOneEnd >= idxOneStart && idxTwoEnd >= idxTwoStart && wordsOne[idxOneEnd].equals(wordsTwo[idxTwoEnd])) {
+            idxOneEnd--;
+            idxTwoEnd--;
+        }
+        if (idxOneEnd != idxOneStart - 1 && idxTwoEnd != idxTwoStart - 1) {
+            return false;
+        }
+        return true;
     }
-    if (targetStartIdx == target.length) {
-      return true;
-    }
-    int targetEndIdx = target.length - 1;
-    matcherCurrentIdx = matcher.length - 1;
-    while (targetEndIdx >= targetStartIdx && matcherCurrentIdx >= 0) {
-      if (!matcher[matcherCurrentIdx].equals(target[targetEndIdx])) {
-        return false;
-      }
-      targetEndIdx--;
-      matcherCurrentIdx--;
-    }
-    return targetEndIdx == targetStartIdx - 1;
-  }
 }

From ca3dcbee5b4c14751ab1f56532a9380a004dd1bc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 7 Oct 2024 17:31:53 -0700
Subject: [PATCH 2094/2175] Create Minimum Number of Swaps to Make the String
 Balanced.java

---
 ... of Swaps to Make the String Balanced.java | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Minimum Number of Swaps to Make the String Balanced.java

diff --git a/Medium/Minimum Number of Swaps to Make the String Balanced.java b/Medium/Minimum Number of Swaps to Make the String Balanced.java
new file mode 100644
index 00000000..79935f13
--- /dev/null
+++ b/Medium/Minimum Number of Swaps to Make the String Balanced.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int minSwaps(String s) {
+        char[] chars = s.toCharArray();
+        Stack<Integer> openBrackets = new Stack<>();
+        for (int i = 0; i < chars.length; i++) {
+            if (chars[i] == '[') {
+                openBrackets.push(i);
+            }
+        }
+        int open = 0;
+        int swaps = 0;
+        for (int i = 0; i < chars.length; i++) {
+            open += chars[i] == '[' ? 1 : -1;
+            if (open < 0) {
+                swaps++;
+                int endIdx = openBrackets.pop();
+                chars[endIdx] = ']';
+                chars[i] = '[';
+                open += 2;
+            }
+        }
+        return swaps;
+    }
+}

From 6b30e46841a64facd6a0ce6652b3b791c22b4071 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Oct 2024 08:03:17 -0700
Subject: [PATCH 2095/2175] Update Minimum Add to Make Parentheses Valid.java

---
 ...Minimum Add to Make Parentheses Valid.java | 24 ++++++++-----------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/Medium/Minimum Add to Make Parentheses Valid.java b/Medium/Minimum Add to Make Parentheses Valid.java
index f119bfe7..7fcfc88d 100644
--- a/Medium/Minimum Add to Make Parentheses Valid.java	
+++ b/Medium/Minimum Add to Make Parentheses Valid.java	
@@ -1,18 +1,14 @@
 class Solution {
-  public int minAddToMakeValid(String s) {
-    int count = 0;
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-      if (c == '(') {
-        stack.push(c);
-      } else {
-        if (stack.isEmpty()) {
-          count++;
-        } else {
-          stack.pop();
+    public int minAddToMakeValid(String s) {
+        int open = 0;
+        int count = 0;
+        for (char c : s.toCharArray()) {
+            open += c == '(' ? 1 : -1;
+            if (open < 0) {
+                count += Math.abs(open);
+                open = 0;
+            }
         }
-      }
+        return count + open;
     }
-    return count + stack.size();
-  }
 }

From d1379d8078e538484116cb808a78388380b306f0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Oct 2024 10:14:41 -0700
Subject: [PATCH 2096/2175] Create Maximum Coins Heroes Can Collect.java

---
 medium/Maximum Coins Heroes Can Collect.java | 40 ++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 medium/Maximum Coins Heroes Can Collect.java

diff --git a/medium/Maximum Coins Heroes Can Collect.java b/medium/Maximum Coins Heroes Can Collect.java
new file mode 100644
index 00000000..1e98abf9
--- /dev/null
+++ b/medium/Maximum Coins Heroes Can Collect.java	
@@ -0,0 +1,40 @@
+class Solution {
+    public long[] maximumCoins(int[] heroes, int[] monsters, int[] coins) {
+        List<MonsterEntity> monsterEntities = new ArrayList<>();
+        int n = monsters.length;
+        for (int i = 0; i < n; i++) {
+            monsterEntities.add(new MonsterEntity(monsters[i], coins[i]));
+        }
+        Collections.sort(monsterEntities, (a, b) -> (a.health() - b.health()));
+        long[] prefixCoinSum = new long[n];
+        for (int i = 0; i < n; i++) {
+            prefixCoinSum[i] = i == 0 ? 0 : prefixCoinSum[i - 1];
+            prefixCoinSum[i] += monsterEntities.get(i).coin();
+        }
+        int m = heroes.length;
+        long[] result = new long[m];
+        for (int i = 0; i < m; i++) {
+            int idx = binarySearch(monsterEntities, heroes[i]);
+            result[i] = idx != Integer.MIN_VALUE ? prefixCoinSum[idx] : 0;
+        }
+        return result;
+    }
+
+    private int binarySearch(List<MonsterEntity> monsterEntities, int heroHealth) {
+        int left = 0;
+        int right = monsterEntities.size() - 1;
+        int idx = Integer.MIN_VALUE;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (monsterEntities.get(mid).health() <= heroHealth) {
+                idx = Math.max(idx, mid);
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return idx;
+    }
+
+    private static record MonsterEntity(int health, int coin) {}
+}

From e5760b1d4aaeae4b661093b3dec2e62b541545e6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 9 Oct 2024 10:15:04 -0700
Subject: [PATCH 2097/2175] Rename Maximum Coins Heroes Can Collect.java to
 Maximum Coins Heroes Can Collect.java

---
 {medium => Medium}/Maximum Coins Heroes Can Collect.java | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {medium => Medium}/Maximum Coins Heroes Can Collect.java (100%)

diff --git a/medium/Maximum Coins Heroes Can Collect.java b/Medium/Maximum Coins Heroes Can Collect.java
similarity index 100%
rename from medium/Maximum Coins Heroes Can Collect.java
rename to Medium/Maximum Coins Heroes Can Collect.java

From d56f44da8d3fdbae82f4e27bef44e27488c5287e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 10 Oct 2024 08:39:16 -0700
Subject: [PATCH 2098/2175] Update Maximum Width Ramp.java

---
 Medium/Maximum Width Ramp.java | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Medium/Maximum Width Ramp.java b/Medium/Maximum Width Ramp.java
index 37eb1862..2463f02b 100644
--- a/Medium/Maximum Width Ramp.java	
+++ b/Medium/Maximum Width Ramp.java	
@@ -1,21 +1,18 @@
 class Solution {
-    public int maxWidthRamp(int[] A) {
+    public int maxWidthRamp(int[] nums) {
+        int n = nums.length;
         Stack<Integer> stack = new Stack<>();
-        int ans = 0;
-        int n = A.length;
-
-        for (int i=0; i<n; i++) {
-            if (stack.isEmpty() || A[stack.peek()] > A[i]) {
-                stack.add(i);
+        for (int i = 0; i < n; i++) {
+            if (stack.isEmpty() || nums[stack.peek()] > nums[i]) {
+                stack.push(i);
             }
         }
-
-        for (int i=n-1; i>=ans; i--) {
-            while (!stack.isEmpty() && A[stack.peek()] <= A[i]) {
-                ans = Math.max(ans, i - stack.pop());
+        int result = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            while (!stack.isEmpty() && nums[stack.peek()] <= nums[i]) {
+                result = Math.max(result, i - stack.pop());
             }
         }
-
-        return ans;
+        return result;
     }
 }

From ffe05dfbf9f0fbb017472657a1119a14474af94f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Oct 2024 14:37:42 -0700
Subject: [PATCH 2099/2175] Create The Number of the Smallest Unoccupied
 Chair.java

---
 ...mber of the Smallest Unoccupied Chair.java | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 Medium/The Number of the Smallest Unoccupied Chair.java

diff --git a/Medium/The Number of the Smallest Unoccupied Chair.java b/Medium/The Number of the Smallest Unoccupied Chair.java
new file mode 100644
index 00000000..6bd41ad2
--- /dev/null
+++ b/Medium/The Number of the Smallest Unoccupied Chair.java	
@@ -0,0 +1,35 @@
+class Solution {
+    public int smallestChair(int[][] times, int targetFriend) {
+        PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> {
+            int c = o1[0] - o2[0];
+            if (c == 0) {
+                return o1[1] - o2[1];
+            }
+            return c;
+        });
+        for (int i = 0; i < times.length; i++) {
+            pq.add(new int[]{times[i][0], times[i][1], i});
+        }
+        PriorityQueue<int[]> occupiedChairs = new PriorityQueue<>(Comparator.comparingInt(o -> o[0]));
+        PriorityQueue<Integer> emptyChairs = new PriorityQueue<>();
+        int currChair = 0;
+        while (!pq.isEmpty()) {
+            int[] time = pq.poll();
+            while (!occupiedChairs.isEmpty() && occupiedChairs.peek()[0] <= time[0]) {
+                int[] chair = occupiedChairs.poll();
+                emptyChairs.add(chair[1]);
+            }
+            if (time[2] == targetFriend) {
+                return emptyChairs.isEmpty() ? currChair : emptyChairs.poll();
+            }
+            if (emptyChairs.isEmpty()) {
+                occupiedChairs.add(new int[]{time[1], currChair});
+                currChair++;
+            } else {
+                int chair = emptyChairs.poll();
+                occupiedChairs.add(new int[]{time[1], chair});
+            }
+        }
+        return -1;
+    }
+}

From 771c1a5b06c14648c4c4e2f3a3f7aefa668f4039 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 11 Oct 2024 14:38:57 -0700
Subject: [PATCH 2100/2175] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a90fb07e..617cd951 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 1600+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1700+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count

From 139140dd8a5224d3c7ce675b118d0c2dd0ac89f8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 12 Oct 2024 07:49:28 -0700
Subject: [PATCH 2101/2175] Create Divide Intervals Into Minimum Number of
 Groups.java

---
 ...tervals Into Minimum Number of Groups.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Divide Intervals Into Minimum Number of Groups.java

diff --git a/Medium/Divide Intervals Into Minimum Number of Groups.java b/Medium/Divide Intervals Into Minimum Number of Groups.java
new file mode 100644
index 00000000..b58d0dcb
--- /dev/null
+++ b/Medium/Divide Intervals Into Minimum Number of Groups.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int minGroups(int[][] intervals) {
+        Arrays.sort(intervals, (o1, o2) -> {
+            int c = Integer.compare(o1[0], o2[0]);
+            if (c == 0) {
+                return Integer.compare(o1[1], o2[1]);
+            }
+            return c;
+        });
+        int max = 0;
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        for (int[] interval : intervals) {
+            while (!pq.isEmpty() && pq.peek() < interval[0]) {
+                pq.poll();
+            }
+            pq.add(interval[1]);
+            max = Math.max(max, pq.size());
+        }
+        return max;
+    }
+}

From ab2e5bd95da86a9fd92c7774644c1e91fe14840e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Oct 2024 16:00:28 -0700
Subject: [PATCH 2102/2175] Create Smallest Range Covering Elements from K
 Lists.java

---
 ... Range Covering Elements from K Lists.java | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Hard/Smallest Range Covering Elements from K Lists.java

diff --git a/Hard/Smallest Range Covering Elements from K Lists.java b/Hard/Smallest Range Covering Elements from K Lists.java
new file mode 100644
index 00000000..4e814027
--- /dev/null
+++ b/Hard/Smallest Range Covering Elements from K Lists.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int[] smallestRange(List<List<Integer>> nums) {
+        PriorityQueue<int[]> pq = new PriorityQueue<>(
+            Comparator.comparingInt(a -> a[0]));
+        int max = Integer.MIN_VALUE;
+        int start = 0;
+        int end = Integer.MAX_VALUE;
+        for (int i = 0; i < nums.size(); i++) {
+            pq.add(new int[]{nums.get(i).get(0), i, 0});
+            max = Math.max(max, nums.get(i).get(0));
+        }
+        while (pq.size() == nums.size()) {
+            int[] removed = pq.poll();
+            int min = removed[0];
+            int row = removed[1];
+            int col = removed[2];
+            if (max - min < end - start) {
+                start = min;
+                end = max;
+            }
+            if (col + 1 < nums.get(row).size()) {
+                int next = nums.get(row).get(col + 1);
+                pq.add(new int[]{next, row, col + 1});
+                max = Math.max(max, next);
+            }
+        }
+        return new int[]{start, end};
+    }
+}

From 74177e433ba8c9723053bf93afd433a275d184a7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Oct 2024 07:48:08 -0700
Subject: [PATCH 2103/2175] Create Separate Black and White Balls.java

---
 Medium/Separate Black and White Balls.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Medium/Separate Black and White Balls.java

diff --git a/Medium/Separate Black and White Balls.java b/Medium/Separate Black and White Balls.java
new file mode 100644
index 00000000..5fc4900f
--- /dev/null
+++ b/Medium/Separate Black and White Balls.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public long minimumSteps(String s) {
+        int whitePos = 0;
+        long swaps = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == '0') {
+                swaps += i - whitePos;
+                whitePos++;
+            }
+        }
+        return swaps;
+    }
+}

From d69d6fa23d5303c23a6bb1e7882f71cc5a3faccf Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Oct 2024 07:54:33 -0700
Subject: [PATCH 2104/2175] Update First Unique Number.java

---
 Medium/First Unique Number.java | 75 ++++++++-------------------------
 1 file changed, 17 insertions(+), 58 deletions(-)

diff --git a/Medium/First Unique Number.java b/Medium/First Unique Number.java
index d5406335..6affb411 100644
--- a/Medium/First Unique Number.java	
+++ b/Medium/First Unique Number.java	
@@ -1,68 +1,27 @@
 class FirstUnique {
-  
-  private Node head;
-  private Node tail;
-  private Map<Integer, Node> map;
-  
-  public FirstUnique(int[] nums) {
-    this.head = new Node(-1);
-    this.tail = new Node(-1);
-    this.head.next = this.tail;
-    this.tail.prev = this.head;
-    this.map = new HashMap<>();
-    for (int num : nums) {
-      if (map.containsKey(num)) {
-        deleteNode(map.get(num));
-      } else {
-        Node node = new Node(num);
-        map.put(num, node);
-        addToTail(node);
-      }
-    }
-  }
 
-  public int showFirstUnique() {
-    return this.head.next.val;
-  }
+    private Map<Integer, Integer> map;
+    private Queue<Integer> queue;
 
-  public void add(int value) {
-    if (map.containsKey(value)) {
-      deleteNode(map.get(value));
-      return;
+    public FirstUnique(int[] nums) {
+        map = new HashMap<>();
+        queue = new LinkedList<>();
+        for (int num : nums) {
+            add(num);
+        }
     }
-    Node node = new Node(value);
-    map.put(value, node);
-    addToTail(node);
-  }
-  
-  private void addToTail(Node node) {
-    Node prevToTail = this.tail.prev;
-    prevToTail.next = node;
-    node.next = this.tail;
-    node.prev = prevToTail;
-    this.tail.prev = node;
-  }
-  
-  private void deleteNode(Node node) {
-    if (node == null) {
-      return;
+    
+    public int showFirstUnique() {
+        while (!queue.isEmpty() && map.get(queue.peek()) > 1) {
+            queue.remove();
+        }
+        return queue.isEmpty() ? -1 : queue.peek();
     }
-    map.put(node.val, null);
-    Node prevToNode = node.prev;
-    Node nextToNode = node.next;
-    prevToNode.next = nextToNode;
-    nextToNode.prev = prevToNode;
-  }
-  
-  private static class Node {
-    int val;
-    Node next;
-    Node prev;
     
-    public Node(int val) {
-      this.val = val;
+    public void add(int value) {
+        queue.add(value);
+        map.put(value, map.getOrDefault(value, 0) + 1);
     }
-  }
 }
 
 /**

From 40e30d0c6424c785b8b51c8f435175dd3b762054 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 16 Oct 2024 07:00:08 -0700
Subject: [PATCH 2105/2175] Update Longest Happy String.java

---
 Medium/Longest Happy String.java | 74 ++++++++++++++++----------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/Medium/Longest Happy String.java b/Medium/Longest Happy String.java
index 145fd638..4af8f747 100644
--- a/Medium/Longest Happy String.java	
+++ b/Medium/Longest Happy String.java	
@@ -1,42 +1,42 @@
 class Solution {
-  public String longestDiverseString(int a, int b, int c) {
-    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((o1, o2) -> o2[1] - o1[1]);
-    if (a > 0) {
-      priorityQueue.add(new int[]{0, a});
-    }
-    if (b > 0) {
-      priorityQueue.add(new int[]{1, b});
-    }
-    if (c > 0) {
-      priorityQueue.add(new int[]{2, c});
-    }
-    StringBuilder sb = new StringBuilder("zz");
-    while (!priorityQueue.isEmpty()) {
-      int[] temp = {-1, -1};
-      char peekChar = (char) ('a' + priorityQueue.peek()[0]);
-      if (peekChar == sb.charAt(sb.length() - 1) && 
-          peekChar == sb.charAt(sb.length() - 2)) {
-        temp[0] = priorityQueue.peek()[0];
-        temp[1] = priorityQueue.peek()[1];
-        priorityQueue.poll();
-        if (priorityQueue.isEmpty()) {
-          break;
+    public String longestDiverseString(int a, int b, int c) {
+        PriorityQueue<LetterFrequencyPair> pq =
+                new PriorityQueue<>((p, q) -> q.frequency() - p.frequency());
+        if (a > 0) {
+            pq.add(new LetterFrequencyPair('a', a));
+        }
+        if (b > 0) {
+            pq.add(new LetterFrequencyPair('b', b));
+        }
+        if (c > 0) {
+            pq.add(new LetterFrequencyPair('c', c));
         }
-      }
-      peekChar = (char) ('a' + priorityQueue.peek()[0]);
-      if (peekChar != sb.charAt(sb.length() - 1) || 
-          peekChar != sb.charAt(sb.length() - 2)) {
-        int[] removed = priorityQueue.poll();
-        sb.append(peekChar);
-        removed[1]--;
-        if (removed[1] > 0) {
-          priorityQueue.add(removed);
+        StringBuilder sb = new StringBuilder();
+        while (!pq.isEmpty()) {
+            LetterFrequencyPair removed = pq.remove();
+            int frequency = removed.frequency();
+            int resultLength = sb.length();
+            if (resultLength >= 2 &&
+                    sb.charAt(resultLength - 1) == removed.letter() &&
+                    sb.charAt(resultLength - 2) == removed.letter()) {
+                if (pq.isEmpty()) {
+                    break;
+                }
+                LetterFrequencyPair temp = pq.remove();
+                sb.append(temp.letter());
+                if (temp.frequency() - 1 > 0) {
+                    pq.add(new LetterFrequencyPair(temp.letter(), temp.frequency() - 1));
+                }
+            } else {
+                sb.append(removed.letter());
+                frequency--;
+            }
+            if (frequency > 0) {
+                pq.add(new LetterFrequencyPair(removed.letter(), frequency));
+            }
         }
-      }
-      if (temp[0] != -1) {
-        priorityQueue.add(temp);
-      }
+        return sb.toString();
     }
-    return sb.substring(2).toString();
-  }
+
+    private record LetterFrequencyPair(char letter, int frequency) {}
 }

From 45105d882a6f2b03e88fc2198a54990a1b91e620 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 17 Oct 2024 07:04:29 -0700
Subject: [PATCH 2106/2175] Update Maximum Swap.java

---
 Medium/Maximum Swap.java | 41 ++++++++++++++++------------------------
 1 file changed, 16 insertions(+), 25 deletions(-)

diff --git a/Medium/Maximum Swap.java b/Medium/Maximum Swap.java
index 5d30c780..c12fb12e 100644
--- a/Medium/Maximum Swap.java	
+++ b/Medium/Maximum Swap.java	
@@ -1,29 +1,20 @@
 class Solution {
-  public int maximumSwap(int num) {
-    String stringValue = Integer.toString(num);
-    Map<Integer, Integer> valToIndexMap = new HashMap<>();
-    int[] digits = new int[String.valueOf(num).length()];
-    for (int i = digits.length - 1; i >= 0; i--) {
-      int digit = num % 10;
-      num /= 10;
-      digits[i] = digit;
-      valToIndexMap.putIfAbsent(digit, i);
-    }
-    for (int i = 0; i < digits.length; i++) {
-      for (int k = 9; k > digits[i]; k--) {
-        if (valToIndexMap.getOrDefault(k, -1) > i) {
-          int swapIndex = valToIndexMap.get(k);
-          return Integer.parseInt(
-              stringValue.substring(0, i) // Digits before swap index
-                  + k // Swapped value
-                  + stringValue.substring(i + 1, swapIndex) // Digits after original index(i) and before swappedIndex
-                  + digits[i] // Digit at original index(i)
-                  + ((swapIndex + 1) != stringValue.length() // Check if swapIndex is last digit of num
-                      ? stringValue.substring(swapIndex + 1) // If not then add digits that come after the swapIndex
-                      : "")); // Else add an empty string
+    public int maximumSwap(int num) {
+        char[] digits = String.valueOf(num).toCharArray();
+        int n = digits.length;
+        int[] maxRightIdx = new int[n];
+        maxRightIdx[n - 1] = n - 1;
+        for (int i = n - 2; i >= 0; i--) {
+            maxRightIdx[i] = (digits[i] > digits[maxRightIdx[i + 1]]) ? i : maxRightIdx[i + 1];
+        }
+        for (int i = 0; i < n; i++) {
+            if (digits[i] < digits[maxRightIdx[i]]) {
+                char temp = digits[i];
+                digits[i] = digits[maxRightIdx[i]];
+                digits[maxRightIdx[i]] = temp;
+                return Integer.parseInt(String.valueOf(digits));
+            }
         }
-      }
+        return num;
     }
-    return Integer.parseInt(stringValue);
-  }
 }

From 0190cfd86d0c79f6ba0a2c265aa81086a960ff1c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 18 Oct 2024 08:15:08 -0700
Subject: [PATCH 2107/2175] Create Count Number of Maximum Bitwise-OR
 Subsets.java

---
 ... Number of Maximum Bitwise-OR Subsets.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Count Number of Maximum Bitwise-OR Subsets.java

diff --git a/Medium/Count Number of Maximum Bitwise-OR Subsets.java b/Medium/Count Number of Maximum Bitwise-OR Subsets.java
new file mode 100644
index 00000000..973e1818
--- /dev/null
+++ b/Medium/Count Number of Maximum Bitwise-OR Subsets.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int countMaxOrSubsets(int[] nums) {
+        int n = nums.length;
+        int maxValue = 0;
+        for (int num : nums) {
+            maxValue |= num;
+        }
+        Integer[][] dp = new Integer[n][maxValue + 1];
+        return countMaxOrSubsets(nums, 0, 0, maxValue, dp);
+    }
+
+    private int countMaxOrSubsets(int[] nums, int idx, int current, int maxValue, Integer[][] dp) {
+        if (idx == nums.length) {
+            return (current == maxValue) ? 1 : 0;
+        }
+        if (dp[idx][current] != null) {
+            return dp[idx][current];
+        }
+        int countWithout = countMaxOrSubsets(nums, idx + 1, current, maxValue, dp);
+        int countWith = countMaxOrSubsets(nums, idx + 1, current | nums[idx], maxValue, dp);
+        return dp[idx][current] = countWith + countWithout;
+    }
+}

From 3a2e60db99c494d79a72a64121306fb5fed66e9e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 19 Oct 2024 08:48:07 -0700
Subject: [PATCH 2108/2175] Create Find Kth Bit in Nth Binary String.java

---
 Medium/Find Kth Bit in Nth Binary String.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Medium/Find Kth Bit in Nth Binary String.java

diff --git a/Medium/Find Kth Bit in Nth Binary String.java b/Medium/Find Kth Bit in Nth Binary String.java
new file mode 100644
index 00000000..e98b29c7
--- /dev/null
+++ b/Medium/Find Kth Bit in Nth Binary String.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public char findKthBit(int n, int k) {
+        return nthString(n).charAt(k - 1);
+    }
+
+    private String nthString(int n) {
+        if (n == 1) {
+            return "0";
+        }
+        String prevString = nthString(n - 1);
+        return prevString + "1" + reverseAndInvert(prevString);
+    }
+
+    private String reverseAndInvert(String s) {
+        char[] chars = s.toCharArray();
+        for (int i = 0; i < s.length(); i++) {
+            chars[i] = chars[i] == '1' ? '0' : '1';
+        }
+        StringBuilder sb = new StringBuilder(String.valueOf(chars));
+        return sb.reverse().toString();
+    }
+}

From a3143e2bc5be251f4b005133f7582b848c52c573 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 20 Oct 2024 09:25:50 -0700
Subject: [PATCH 2109/2175] Update Parsing A Boolean Expression.java

---
 Hard/Parsing A Boolean Expression.java | 91 +++++++++-----------------
 1 file changed, 31 insertions(+), 60 deletions(-)

diff --git a/Hard/Parsing A Boolean Expression.java b/Hard/Parsing A Boolean Expression.java
index 2c419aa8..97a56130 100644
--- a/Hard/Parsing A Boolean Expression.java	
+++ b/Hard/Parsing A Boolean Expression.java	
@@ -1,72 +1,43 @@
 class Solution {
     public boolean parseBoolExpr(String expression) {
-        char[] chars = expression.toCharArray();
-        Stack<Character> operations = new Stack<>();
-        Stack<Character> boolValues = new Stack<>();
-
-        for (int i = 0; i < chars.length; i++) {
-            char c = chars[i];
-            if (c == '!' || c == '&' || c == '|') {
-                operations.push(c);
-            }
-            else if (c == '(') {
-                boolValues.push('#');
-            }
-            else if (c == 't' || c == 'f') {
-                boolValues.push(chars[i]);
-            }
-            else if (c == ',') {
-                continue;
-            }
-            else {
-                List<Character> list = new ArrayList<>();
-                while (!boolValues.isEmpty()) {
-                    char temp = boolValues.pop();
-                    if (temp == '#') {
-                        break;
-                    }
-
-                    list.add(temp);
+        Stack<Character> stack = new Stack<>();
+        for (char c : expression.toCharArray()) {
+            if (c == ')') {
+                List<Character> values = new ArrayList<>();
+                while (stack.peek() != '(') {
+                    values.add(stack.pop());
                 }
-                
-                boolValues.push(performOperation(list, operations.pop()));
+                stack.pop();
+                char operation = stack.pop();
+                char result = evaluate(operation, values);
+                stack.push(result);
+            } else if (c != ',') {
+                stack.push(c);
             }
         }
-
-        return boolValues.peek() == 't' ? true : false;
+        return stack.peek() == 't';
     }
 
-    private Character performOperation(List<Character> list, Character operation) {
-        if (operation == '|') {
-            return performOr(list);
-        }
-        else if (operation == '&') {
-            return performAnd(list);
+    private static char evaluate(char operation, List<Character> values) {
+        if (operation == '!') {
+            return values.get(0) == 't' ? 'f' : 't';
         }
-        else {
-            return list.get(0) == 't' ? 'f' : 't';
-        }
-    }
-
-    private Character performAnd(List<Character> list) {
-        boolean val = getBooleanValue(list.get(0));
-        for (int i = 1; i < list.size(); i++) {
-            val &= getBooleanValue(list.get(i));
+        if (operation == '&') {
+            for (char value : values) {
+                if (value == 'f') {
+                    return 'f';
+                }
+            }
+            return 't';
         }
-
-        return val ? 't' : 'f';
-    }
-
-    private Character performOr(List<Character> list) {
-        boolean val = getBooleanValue(list.get(0));
-        for (int i = 1; i < list.size(); i++) {
-            val |= getBooleanValue(list.get(i));
+        if (operation == '|') {
+            for (char value : values) {
+                if (value == 't') {
+                    return 't';
+                }
+            }
+            return 'f';
         }
-
-        return val ? 't' : 'f';
-    }
-
-    private boolean getBooleanValue(Character character) {
-        return character == 't' ? true : false;
+        return 'f';
     }
 }

From 7b253d794e4f465cb89df85bee72000915f06ad3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 21 Oct 2024 12:40:07 -0700
Subject: [PATCH 2110/2175] Create Split a String Into the Max Number of Unique
 Substrings.java

---
 ...o the Max Number of Unique Substrings.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Split a String Into the Max Number of Unique Substrings.java

diff --git a/Medium/Split a String Into the Max Number of Unique Substrings.java b/Medium/Split a String Into the Max Number of Unique Substrings.java
new file mode 100644
index 00000000..3e418df7
--- /dev/null
+++ b/Medium/Split a String Into the Max Number of Unique Substrings.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int maxUniqueSplit(String s) {
+        Set<String> seen = new HashSet<>();
+        return backtrack(s, 0, seen);
+    }
+
+    private int backtrack(String s, int idx, Set<String> seen) {
+        if (idx == s.length()) {
+            return 0;
+        }
+        int count = 0;
+        for (int end = idx + 1; end <= s.length(); end++) {
+            String substring = s.substring(idx, end);
+            if (seen.add(substring)) {
+                count = Math.max(count, 1 + backtrack(s, end, seen));
+                seen.remove(substring);
+            }
+        }
+        return count;
+    }
+}

From 975d71b3150dcf4772c7b542b8b6765c03f92e90 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 23 Oct 2024 06:42:23 -0700
Subject: [PATCH 2111/2175] Create Cousins in Binary Tree II.java

---
 Medium/Cousins in Binary Tree II.java | 44 +++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 Medium/Cousins in Binary Tree II.java

diff --git a/Medium/Cousins in Binary Tree II.java b/Medium/Cousins in Binary Tree II.java
new file mode 100644
index 00000000..ee1b4b21
--- /dev/null
+++ b/Medium/Cousins in Binary Tree II.java	
@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode replaceValueInTree(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        int prevLevelSum = root.val;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            int levelSum = 0;
+            for (int i = 0; i < size; i++) {
+                TreeNode node = queue.remove();
+                node.val = prevLevelSum - node.val;
+                int siblingSum = (node.left != null ? node.left.val : 0) + 
+                    (node.right != null ? node.right.val : 0); 
+                if (node.left != null) {
+                    levelSum += node.left.val;
+                    node.left.val = siblingSum;
+                    queue.add(node.left);
+                }
+                if (node.right != null) {
+                    levelSum += node.right.val;
+                    node.right.val = siblingSum;
+                    queue.add(node.right);
+                }
+            }
+            prevLevelSum = levelSum;
+        }
+        return root;
+    }
+}

From 2dea3e54c58e5a45993f084c75aca141c5ca978f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 24 Oct 2024 07:18:31 -0700
Subject: [PATCH 2112/2175] Update Flip Equivalent Binary Trees.java

---
 Medium/Flip Equivalent Binary Trees.java | 42 ++++++++++++------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/Medium/Flip Equivalent Binary Trees.java b/Medium/Flip Equivalent Binary Trees.java
index 7829ff4d..8590505e 100644
--- a/Medium/Flip Equivalent Binary Trees.java	
+++ b/Medium/Flip Equivalent Binary Trees.java	
@@ -1,31 +1,31 @@
-i/**
+/**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  public boolean flipEquiv(TreeNode root1, TreeNode root2) {
-    if (root1 == null && root2 == null) {
-      return true;
+    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
+        if (root1 == null && root2 == null) {
+            return true;
+        }
+        if (root1 == null || root2 == null) {
+            return false;
+        }
+        if (root1.val != root2.val) {
+            return false;
+        }
+        boolean noSwap = flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right);
+        boolean swap = flipEquiv(root1.left, root2.right) && flipEquiv(root1.right, root2.left);
+        return noSwap || swap;
     }
-    if (root1 == null || root2 == null) {
-      return false;
-    }
-    if (root1.val != root2.val) {
-      return false;
-    }
-    return (
-        (
-          flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right)
-        ) || 
-        (
-          flipEquiv(root1.left, root2.right) && 
-          flipEquiv(root1.right, root2.left)
-        )
-      );
-  }
 }

From 07715d08a8f45047ee39fbc6ed05247406a7d8ce Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 25 Oct 2024 07:34:43 -0700
Subject: [PATCH 2113/2175] Update Remove Sub-Folders from the Filesystem.java

---
 ...emove Sub-Folders from the Filesystem.java | 83 ++++++++++++++-----
 1 file changed, 63 insertions(+), 20 deletions(-)

diff --git a/Medium/Remove Sub-Folders from the Filesystem.java b/Medium/Remove Sub-Folders from the Filesystem.java
index 2d91c97e..62f67bcd 100644
--- a/Medium/Remove Sub-Folders from the Filesystem.java	
+++ b/Medium/Remove Sub-Folders from the Filesystem.java	
@@ -1,24 +1,67 @@
 class Solution {
-  public List<String> removeSubfolders(String[] folder) {
-    Set<String> set = new HashSet<>();
-    Arrays.sort(folder, new Comparator<String>(){
-      public int compare(String s1, String s2) {
-        return s1.length() - s2.length();
-      }
-    });
-    for (String fl : folder) {
-      String[] files = fl.split("/");
-      StringBuilder sb = new StringBuilder();
-      for (int i = 1; i < files.length; i++) {
-        sb.append("/").append(files[i]);
-        if (set.contains(sb.toString())) {
-          break;
+    public List<String> removeSubfolders(String[] folder) {
+        TrieNode root = new TrieNode();
+        for (String file : folder) {
+            TrieNode curr = root;
+            String[] splits = file.split("/");
+            for (int i = 1; i < splits.length; i++) {
+                Optional<TrieNode> nextNode = curr.getChild(splits[i]);
+                if (nextNode.isEmpty()) {
+                    TrieNode newNode = curr.addChild(splits[i]);
+                    curr = newNode;
+                } else {
+                    curr = nextNode.get();
+                }
+            }
+            curr.markIsFolder();
+        }
+        List<String> result = new ArrayList<>();
+        for (String file : folder) {
+            TrieNode curr = root;
+            String[] splits = file.split("/");
+            boolean isSubfolder = false;
+            for (int i = 1; i < splits.length; i++) {
+                TrieNode nextNode = curr.getChild(splits[i]).get();
+                if (nextNode.isFolder() && i != splits.length - 1) {
+                    isSubfolder = true;
+                    break;
+                }
+                curr = nextNode;
+            }
+            if (!isSubfolder) {
+                result.add(file);
+            }
+        }
+        return result;
+    }
+
+    class TrieNode {
+        private boolean isFolder;
+        private Map<String, TrieNode> children;
+
+        public TrieNode() {
+            this.children = new HashMap<>();
+        }
+
+        public TrieNode addChild(String childKey) {
+            TrieNode node = new TrieNode();
+            children.put(childKey, node);
+            return node;
+        }
+
+        public Optional<TrieNode> getChild(String childKey) {
+            if (!children.containsKey(childKey)) {
+                return Optional.empty();
+            }
+            return Optional.of(children.get(childKey));
+        }
+
+        public void markIsFolder() {
+            isFolder = true;
+        }
+
+        public boolean isFolder() {
+            return isFolder;
         }
-      }
-      if (sb.length() > 0) {
-        set.add(sb.toString());
-      }
     }
-    return new ArrayList<>(set);
-  }
 }

From 65583aed6e8c71a04f047c3bb1e8cc03c0249cf0 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Oct 2024 09:22:03 -0700
Subject: [PATCH 2114/2175] Create Height of Binary Tree After Subtree Removal
 Queries.java

---
 ...ry Tree After Subtree Removal Queries.java | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 Hard/Height of Binary Tree After Subtree Removal Queries.java

diff --git a/Hard/Height of Binary Tree After Subtree Removal Queries.java b/Hard/Height of Binary Tree After Subtree Removal Queries.java
new file mode 100644
index 00000000..ebd9acbe
--- /dev/null
+++ b/Hard/Height of Binary Tree After Subtree Removal Queries.java	
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int[] treeQueries(TreeNode root, int[] queries) {
+        Map<Integer, Integer> result = new HashMap<>();
+        Map<TreeNode, Integer> heightCache = new HashMap<>();
+        dfs(root, 0, 0, result, heightCache);
+        int[] answer = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            answer[i] = result.get(queries[i]);
+        }
+        return answer;
+    }
+
+    private void dfs(TreeNode node, int depth, int maxDepth, Map<Integer, Integer> result, Map<TreeNode, Integer> heightCache) {
+        if (node == null) {
+            return;
+        }
+        result.put(node.val, maxDepth);
+        dfs(node.left, depth + 1, Math.max(maxDepth, depth + 1 + height(node.right, heightCache)), result, heightCache);
+        dfs(node.right, depth + 1, Math.max(maxDepth, depth + 1 + height(node.left, heightCache)), result, heightCache);
+    }
+    
+    private int height(TreeNode node, Map<TreeNode, Integer> heightCache) {
+        if (node == null) {
+            return -1;
+        }
+        if (heightCache.containsKey(node)) {
+            return heightCache.get(node);
+        }
+        int currHeight = 1 + Math.max(height(node.left, heightCache), height(node.right, heightCache));
+        heightCache.put(node, currHeight);
+        return currHeight;
+    }
+}

From 0d68682d23ee31299361af2a5c059f16ac1f224a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Oct 2024 14:32:07 -0700
Subject: [PATCH 2115/2175] Create Find the Original Typed String I.java

---
 Easy/Find the Original Typed String I.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Find the Original Typed String I.java

diff --git a/Easy/Find the Original Typed String I.java b/Easy/Find the Original Typed String I.java
new file mode 100644
index 00000000..dd6a5177
--- /dev/null
+++ b/Easy/Find the Original Typed String I.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int possibleStringCount(String word) {
+        int idx = 0;
+        int result = 1;
+        while (idx < word.length()) {
+            int currIdx = idx;
+            char c = word.charAt(currIdx);
+            while (currIdx < word.length() && word.charAt(currIdx) == c) {
+                currIdx++;
+            }
+            int segement = currIdx - idx;
+            result += segement - 1;
+            idx = currIdx;
+        }
+        return result;
+    }
+}

From c458cea30a0ff3997b1babb07c871fc154c7eed7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 28 Oct 2024 07:07:44 -0700
Subject: [PATCH 2116/2175] Create Longest Square Streak in an Array.java

---
 Medium/Longest Square Streak in an Array.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Longest Square Streak in an Array.java

diff --git a/Medium/Longest Square Streak in an Array.java b/Medium/Longest Square Streak in an Array.java
new file mode 100644
index 00000000..141abdee
--- /dev/null
+++ b/Medium/Longest Square Streak in an Array.java	
@@ -0,0 +1,25 @@
+class Solution {
+
+    private static final int LIMIT = 100_000;
+
+    public int longestSquareStreak(int[] nums) {
+        Set<Integer> uniqueNums = new HashSet<>();
+        for (int num : nums) {
+            uniqueNums.add(num);
+        }
+        int result = 0;
+        for (int num : nums) {
+            int currStreak = 0;
+            long curr = num;
+            while (uniqueNums.contains((int) curr)) {
+                currStreak++;
+                if (curr * curr > LIMIT) {
+                    break;
+                }
+                curr *= curr;
+            }
+            result = Math.max(result, currStreak);
+        }
+        return result < 2 ? -1 : result;
+    }
+}

From 65c039985ea998ee26bcce26574385d4146caf26 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 29 Oct 2024 08:02:39 -0700
Subject: [PATCH 2117/2175] Create Maximum Number of Moves in a Grid.java

---
 Medium/Maximum Number of Moves in a Grid.java | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 Medium/Maximum Number of Moves in a Grid.java

diff --git a/Medium/Maximum Number of Moves in a Grid.java b/Medium/Maximum Number of Moves in a Grid.java
new file mode 100644
index 00000000..014425f8
--- /dev/null
+++ b/Medium/Maximum Number of Moves in a Grid.java	
@@ -0,0 +1,40 @@
+class Solution {
+
+    private static final int[] DIRS = {-1, 0, 1};
+
+    public int maxMoves(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        Queue<int[]> queue = new LinkedList<>();
+        boolean[][] visited = new boolean[rows][cols];
+        for (int i = 0; i < rows; i++) {
+            visited[i][0] = true;
+            queue.add(new int[]{i, 0, 0});
+        }
+        int result = 0; 
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                int row = removed[0];
+                int col = removed[1];
+                int count = removed[2];
+                result = Math.max(result, count);
+                for (int dir : DIRS) {
+                    int nextRow = row + dir;
+                    int nextCol = col + 1;
+                    if (nextRow >= 0 && 
+                        nextCol >= 0 && 
+                        nextRow < rows && 
+                        nextCol < cols && 
+                        !visited[nextRow][nextCol] &&
+                        grid[row][col] < grid[nextRow][nextCol]) {
+                            visited[nextRow][nextCol] = true;
+                            queue.add(new int[]{nextRow, nextCol, count + 1});
+                        }
+                }
+            }
+        }
+        return result;
+    }
+}

From 2580a677b3a9c0b6cda1a0f7103c57020472cc3a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 30 Oct 2024 06:47:27 -0700
Subject: [PATCH 2118/2175] Create Minimum Number of Removals to Make Mountain
 Array.java

---
 ...er of Removals to Make Mountain Array.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Hard/Minimum Number of Removals to Make Mountain Array.java

diff --git a/Hard/Minimum Number of Removals to Make Mountain Array.java b/Hard/Minimum Number of Removals to Make Mountain Array.java
new file mode 100644
index 00000000..b74f6feb
--- /dev/null
+++ b/Hard/Minimum Number of Removals to Make Mountain Array.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int minimumMountainRemovals(int[] nums) {
+        int n = nums.length;
+        int[] leftIncreasingLength = new int[n];
+        int[] rightDecreasingLength = new int[n];
+        Arrays.fill(leftIncreasingLength, 1);
+        Arrays.fill(rightDecreasingLength, 1);
+        for (int i = 0; i < n; i++) {
+            for (int j = i - 1; j >= 0; j--) {
+                if (nums[i] > nums[j]) {
+                    leftIncreasingLength[i] = Math.max(leftIncreasingLength[i], leftIncreasingLength[j] + 1);
+                }
+            }
+        }
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = i + 1; j < n; j++) {
+                if (nums[i] > nums[j]) {
+                    rightDecreasingLength[i] = Math.max(rightDecreasingLength[i], rightDecreasingLength[j] + 1);
+                }
+            }
+        }
+        int minRemovals = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (leftIncreasingLength[i] > 1 && rightDecreasingLength[i] > 1) {
+                minRemovals = Math.min(minRemovals, n - leftIncreasingLength[i] - rightDecreasingLength[i] + 1);
+            }
+        }
+        return minRemovals;
+    }
+}

From aafb2effbd9500cfb5e24ceae7986147ed70d6ee Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 4 Nov 2024 06:35:54 -0800
Subject: [PATCH 2119/2175] Create String Compression III.java

---
 Medium/String Compression III.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/String Compression III.java

diff --git a/Medium/String Compression III.java b/Medium/String Compression III.java
new file mode 100644
index 00000000..03a6737c
--- /dev/null
+++ b/Medium/String Compression III.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public String compressedString(String word) {
+        StringBuilder sb = new StringBuilder();
+        int idx = 0;
+        while (idx < word.length()) {
+            char c = word.charAt(idx);
+            int count = 0;
+            while (idx < word.length() && word.charAt(idx) == c && count < 9) {
+                idx++;
+                count++;
+            }
+            sb.append(count).append(c);
+        }
+        return sb.toString();
+    }
+}

From 1c1f3cf1277b63af4b230b6dffd3a8f61f7f1497 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 6 Nov 2024 07:25:20 -0800
Subject: [PATCH 2120/2175] Create Number of Same-End Substrings.java

---
 Medium/Number of Same-End Substrings.java | 28 +++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Number of Same-End Substrings.java

diff --git a/Medium/Number of Same-End Substrings.java b/Medium/Number of Same-End Substrings.java
new file mode 100644
index 00000000..4003737d
--- /dev/null
+++ b/Medium/Number of Same-End Substrings.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public int[] sameEndSubstringCount(String s, int[][] queries) {
+        int n = s.length();
+        int[][] prefixSum = new int[26][n];
+        for (int i = 0; i < n; i++) {
+            prefixSum[s.charAt(i) - 'a'][i]++;
+        }
+        for (int i = 0; i < 26; i++) {
+            for (int j = 1; j < n; j++) {
+                prefixSum[i][j] += prefixSum[i][j - 1];
+            }
+        }
+        int[] result = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            int left = queries[i][0];
+            int right = queries[i][1];
+            int count = 0;
+            for (int c = 0; c < 26; c++) {
+                int leftFreq = left == 0 ? 0 : prefixSum[c][left - 1];
+                int rightFreq = prefixSum[c][right];
+                int freqInRange = rightFreq - leftFreq;
+                count += (freqInRange * (freqInRange + 1)) / 2;
+            }
+            result[i] = count;
+        }
+        return result;
+    }
+}

From 5a3795b8956bbe92bbdd5462beae0b5ef2c6abdd Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 7 Nov 2024 08:12:32 -0800
Subject: [PATCH 2121/2175] Create Largest Combination With Bitwise AND Greater
 Than Zero.java

---
 ...tion With Bitwise AND Greater Than Zero.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Largest Combination With Bitwise AND Greater Than Zero.java

diff --git a/Medium/Largest Combination With Bitwise AND Greater Than Zero.java b/Medium/Largest Combination With Bitwise AND Greater Than Zero.java
new file mode 100644
index 00000000..1399f1bb
--- /dev/null
+++ b/Medium/Largest Combination With Bitwise AND Greater Than Zero.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int largestCombination(int[] candidates) {
+        int[] bitCount = new int[24];
+        for (int i = 0; i < 24; i++) {
+            for (int candidate : candidates) {
+                if ((candidate & (1 << i)) != 0) {
+                    bitCount[i]++;
+                }
+            }
+        }
+        int result = 0;
+        for (int count : bitCount) {
+            result = Math.max(count, result);
+        }
+        return result;
+    }
+}

From f1e4d1887ee89e1bcdaf4cb0c6f343bd5c7b6ad1 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 14 Nov 2024 06:35:00 -0800
Subject: [PATCH 2122/2175] Create Minimized Maximum of Products Distributed to
 Any Store.java

---
 ... of Products Distributed to Any Store.java | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 Medium/Minimized Maximum of Products Distributed to Any Store.java

diff --git a/Medium/Minimized Maximum of Products Distributed to Any Store.java b/Medium/Minimized Maximum of Products Distributed to Any Store.java
new file mode 100644
index 00000000..70a46016
--- /dev/null
+++ b/Medium/Minimized Maximum of Products Distributed to Any Store.java	
@@ -0,0 +1,36 @@
+class Solution {
+    public int minimizedMaximum(int n, int[] quantities) {
+        int left = 0;
+        int right = 0;
+        for (int quantity : quantities) {
+            right = Math.max(right, quantity);
+        }
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (isPossible(n, mid, quantities)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    private boolean isPossible(int n, int min, int[] quantities) {
+        int idx = 0;
+        int remaining = quantities[idx];
+        for (int i = 0; i < n; i++) {
+            if (remaining <= min) {
+                idx++;
+                if (idx == quantities.length) {
+                    return true;
+                } else {
+                    remaining = quantities[idx];
+                }
+            } else {
+                remaining -= min;
+            }
+        }
+        return false;
+    }
+}

From ceb871f66e65b8cc2655d9891c555781347d9c1a Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 15 Nov 2024 08:05:15 -0800
Subject: [PATCH 2123/2175] Create Shortest Subarray to be Removed to Make
 Array Sorted.java

---
 ...ray to be Removed to Make Array Sorted.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Medium/Shortest Subarray to be Removed to Make Array Sorted.java

diff --git a/Medium/Shortest Subarray to be Removed to Make Array Sorted.java b/Medium/Shortest Subarray to be Removed to Make Array Sorted.java
new file mode 100644
index 00000000..4ddb25e2
--- /dev/null
+++ b/Medium/Shortest Subarray to be Removed to Make Array Sorted.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int findLengthOfShortestSubarray(int[] arr) {
+        int right = arr.length - 1;
+        while (right > 0 && arr[right] >= arr[right - 1]) {
+            right--;
+        }
+        int result = right;
+        int left = 0;
+        while (left < right && (left == 0 || arr[left - 1] <= arr[left])) {
+            while (right < arr.length && arr[left] > arr[right]) {
+                right++;
+            }
+            result = Math.min(result, right - left - 1);
+            left++;
+        }
+        return result;
+    }
+}

From 5eaf0134b8d8b7eafb7abae9f60e826bcb98b41f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 17 Nov 2024 06:52:36 -0800
Subject: [PATCH 2124/2175] Create Adjacent Increasing Subarrays Detection
 I.java

---
 ...cent Increasing Subarrays Detection I.java | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Adjacent Increasing Subarrays Detection I.java

diff --git a/Easy/Adjacent Increasing Subarrays Detection I.java b/Easy/Adjacent Increasing Subarrays Detection I.java
new file mode 100644
index 00000000..5be82de7
--- /dev/null
+++ b/Easy/Adjacent Increasing Subarrays Detection I.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public boolean hasIncreasingSubarrays(List<Integer> nums, int k) {
+        int n = nums.size();
+        for (int i = 0; i <= n - 2 * k; i++) {
+            if (isStrictlyIncreasing(nums, i, k) && isStrictlyIncreasing(nums, i + k, k)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isStrictlyIncreasing(List<Integer> nums, int idx, int k) {
+        for (int start = idx; start < idx + k - 1; start++) {
+            if (nums.get(start) >= nums.get(start + 1)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From 8738cee338223b3413232342be126e90ac9cf9e2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 20 Nov 2024 08:28:53 -0800
Subject: [PATCH 2125/2175] Create Take K of Each Character From Left and
 Right.java

---
 ...of Each Character From Left and Right.java | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 Medium/Take K of Each Character From Left and Right.java

diff --git a/Medium/Take K of Each Character From Left and Right.java b/Medium/Take K of Each Character From Left and Right.java
new file mode 100644
index 00000000..4b878ce0
--- /dev/null
+++ b/Medium/Take K of Each Character From Left and Right.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int takeCharacters(String s, int k) {
+        int[] counter = new int[3];
+        int n = s.length();
+        for (char c : s.toCharArray()) {
+            counter[c - 'a']++;
+        }
+        for (int i = 0; i < 3; i++) {
+            if (counter[i] < k) {
+                return -1;
+            }
+        }
+        int[] window = new int[3];
+        int left = 0;
+        int maxWindow = 0;
+        for (int right = 0; right < n; right++) {
+            window[s.charAt(right) - 'a']++;
+            while (left <= right && 
+                (counter[0] - window[0] < k || counter[1] - window[1] < k || counter[2] - window[2] < k)) {
+                window[s.charAt(left) - 'a']--;
+                left++;
+            }
+            maxWindow = Math.max(maxWindow, right - left + 1);
+        }
+        return n - maxWindow;
+    }
+}

From 199a76c4f8b272a7c632841e36959c9aa1c8b46c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 22 Dec 2024 05:48:36 +0530
Subject: [PATCH 2126/2175] Create Count Subarrays of Length Three With a
 Condition.java

---
 ...nt Subarrays of Length Three With a Condition.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Easy/Count Subarrays of Length Three With a Condition.java

diff --git a/Easy/Count Subarrays of Length Three With a Condition.java b/Easy/Count Subarrays of Length Three With a Condition.java
new file mode 100644
index 00000000..4694fb65
--- /dev/null
+++ b/Easy/Count Subarrays of Length Three With a Condition.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int countSubarrays(int[] nums) {
+        int count = 0;
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (2 * (nums[i] + nums[i + 2]) == nums[i + 1]) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

From 6735f7a0d2bb149726984a53fb48766c43e7e243 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 23 Dec 2024 06:41:01 +0530
Subject: [PATCH 2127/2175] Create Minimum Number of Operations to Make
 Elements in Array Distinct.java

---
 ...ons to Make Elements in Array Distinct.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Minimum Number of Operations to Make Elements in Array Distinct.java

diff --git a/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java b/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java
new file mode 100644
index 00000000..a61239e7
--- /dev/null
+++ b/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int minimumOperations(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        int index = -1;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            if (set.contains(nums[i])) {
+                index = i;
+                break;
+            }
+            set.add(nums[i]);
+        }
+        if (index == -1) {
+            return 0;
+        }
+        index++;
+        return index % 3 == 0 ? index / 3 : (index / 3) + 1;
+    }
+}

From c8ba8359855d7be2aa9f966f0a9d9a3ae3435dff Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 26 Dec 2024 18:27:19 +0530
Subject: [PATCH 2128/2175] Create Button with Longest Push Time.java

---
 Easy/Button with Longest Push Time.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Easy/Button with Longest Push Time.java

diff --git a/Easy/Button with Longest Push Time.java b/Easy/Button with Longest Push Time.java
new file mode 100644
index 00000000..650bb1e4
--- /dev/null
+++ b/Easy/Button with Longest Push Time.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int buttonWithLongestTime(int[][] events) {
+        int maxTime = 0;
+        int resultIdx = 0;
+        int prevTime = 0;
+        for (int i = 0; i < events.length; i++) {
+            int timePressed = events[i][1] - prevTime;
+            if (timePressed > maxTime) {
+                maxTime = timePressed;
+                resultIdx = events[i][0];
+            } else if (timePressed == maxTime && resultIdx > events[i][0]) {
+                resultIdx = events[i][0];
+            }
+            prevTime = events[i][1];
+        }
+        return resultIdx;
+    }
+}

From 9d4036992d100703cb34fecc1183c457bc4d44af Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 12 Jan 2025 12:23:37 -0800
Subject: [PATCH 2129/2175] Create Check if a Parentheses String Can Be
 Valid.java

---
 ... if a Parentheses String Can Be Valid.java | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 Medium/Check if a Parentheses String Can Be Valid.java

diff --git a/Medium/Check if a Parentheses String Can Be Valid.java b/Medium/Check if a Parentheses String Can Be Valid.java
new file mode 100644
index 00000000..c240176d
--- /dev/null
+++ b/Medium/Check if a Parentheses String Can Be Valid.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public boolean canBeValid(String s, String locked) {
+        if (s.length() % 2 != 0) {
+            return false;
+        }
+        Stack<Integer> openBrackets = new Stack<>();
+        Stack<Integer> unlocked = new Stack<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (locked.charAt(i) == '0') {
+                unlocked.push(i);
+            } else if (c == '(') {
+                openBrackets.push(i);
+            } else if (c == ')') {
+                if (!openBrackets.isEmpty()) {
+                    openBrackets.pop();
+                } else if (!unlocked.isEmpty()) {
+                    unlocked.pop();
+                } else {
+                    return false;
+                }
+            }
+        }
+        while (!openBrackets.isEmpty() && !unlocked.isEmpty() && openBrackets.peek() < unlocked.peek()) {
+            openBrackets.pop();
+            unlocked.pop();
+        }
+        return openBrackets.isEmpty();
+    }
+}

From 0298b447e75aa7ceedb837d55c3790ac0f7073b8 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 14 Jan 2025 06:41:46 -0800
Subject: [PATCH 2130/2175] Update Find the Prefix Common Array of Two
 Arrays.java

---
 ...the Prefix Common Array of Two Arrays.java | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/Medium/Find the Prefix Common Array of Two Arrays.java b/Medium/Find the Prefix Common Array of Two Arrays.java
index bd747227..e6312a17 100644
--- a/Medium/Find the Prefix Common Array of Two Arrays.java	
+++ b/Medium/Find the Prefix Common Array of Two Arrays.java	
@@ -1,14 +1,17 @@
 class Solution {
     public int[] findThePrefixCommonArray(int[] A, int[] B) {
-        Map<Integer, Integer> map = new HashMap<>();
         int count = 0;
-        int[] result = new int[A.length];
-        for (int i = 0; i < A.length; i++) {
-            map.put(A[i], map.getOrDefault(A[i], 0) + 1);
-            map.put(B[i], map.getOrDefault(B[i], 0) + 1);
-            count += map.get(A[i]) == 2 ? 1 : 0;
-            if (A[i] != B[i]) {
-                count += map.get(B[i]) == 2 ? 1 : 0;
+        int n = A.length;
+        int[] result = new int[n];
+        int[] frequency = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            frequency[A[i]]++;
+            if (frequency[A[i]] == 2) {
+                count++;
+            }
+            frequency[B[i]]++;
+            if (frequency[B[i]] == 2) {
+                count++;
             }
             result[i] = count;
         }

From a03b2709db74206a8efecbc2f878d87b808bfc00 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 15 Jan 2025 07:12:59 -0800
Subject: [PATCH 2131/2175] Create Minimize XOR.java

---
 Medium/Minimize XOR.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Minimize XOR.java

diff --git a/Medium/Minimize XOR.java b/Medium/Minimize XOR.java
new file mode 100644
index 00000000..cc5e87a3
--- /dev/null
+++ b/Medium/Minimize XOR.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int minimizeXor(int num1, int num2) {
+        int result = 0;
+        int targetSetBitCount = Integer.bitCount(num2);
+        int setBitCount = 0;
+        int currBit = 31;
+        while (setBitCount < targetSetBitCount) {
+            if (isSet(num1, currBit) || (targetSetBitCount - setBitCount > currBit)) {
+                result = setBit(result, currBit);
+                setBitCount++;
+            }
+            currBit--;
+        }
+        return result;
+    }
+
+    private boolean isSet(int x, int bit) {
+        return (x & (1 << bit)) != 0;
+    }
+
+    private int setBit(int x, int bit) {
+        return x | (1 << bit);
+    }
+}

From fbb599922e136af4abfa4180c747b50e57fc1060 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 15 Jan 2025 17:37:21 -0800
Subject: [PATCH 2132/2175] Create Bitwise XOR of All Pairings.java

---
 Medium/Bitwise XOR of All Pairings.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Medium/Bitwise XOR of All Pairings.java

diff --git a/Medium/Bitwise XOR of All Pairings.java b/Medium/Bitwise XOR of All Pairings.java
new file mode 100644
index 00000000..88dfbd41
--- /dev/null
+++ b/Medium/Bitwise XOR of All Pairings.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int xorAllNums(int[] nums1, int[] nums2) {
+        int m = nums1.length;
+        int n = nums2.length;
+        Map<Integer, Integer> freq = new HashMap<>();
+        for (int num : nums1) {
+            freq.put(num, freq.getOrDefault(num, 0) + n);
+        }
+        for (int num : nums2) {
+            freq.put(num, freq.getOrDefault(num, 0) + m);
+        }
+        int result = 0;
+        for (Integer key : freq.keySet()) {
+            if (freq.get(key) % 2 == 1) {
+                result ^= key;
+            }
+        }
+        return result;
+    }
+}

From e8baf509b7624bb7a17be44df8afd34511d71f4e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 16 Jan 2025 17:13:07 -0800
Subject: [PATCH 2133/2175] Create Neighboring Bitwise XOR.java

---
 Medium/Neighboring Bitwise XOR.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Neighboring Bitwise XOR.java

diff --git a/Medium/Neighboring Bitwise XOR.java b/Medium/Neighboring Bitwise XOR.java
new file mode 100644
index 00000000..6e46025c
--- /dev/null
+++ b/Medium/Neighboring Bitwise XOR.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public boolean doesValidArrayExist(int[] derived) {
+        int n = derived.length;
+        int[] original = new int[n + 1];
+        for (int i = 0; i < derived.length; i++) {
+            original[i + 1] = derived[i] ^ original[i];
+        }
+        boolean checkForZero = (original[0] == original[n]);
+        original[0] = 1;
+        for (int i = 0; i < n; i++) {
+            original[i + 1] = derived[i] ^ original[i];
+        }
+        boolean checkForOne = (original[0] == original[n]);
+        return checkForZero || checkForOne;
+    }
+}

From 72a77c98c7d75ee9a5de805aa885158e8478f12e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 20 Jan 2025 09:55:45 -0800
Subject: [PATCH 2134/2175] Create Sum of Variable Length Subarrays.java

---
 Easy/Sum of Variable Length Subarrays.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Sum of Variable Length Subarrays.java

diff --git a/Easy/Sum of Variable Length Subarrays.java b/Easy/Sum of Variable Length Subarrays.java
new file mode 100644
index 00000000..5dc7d585
--- /dev/null
+++ b/Easy/Sum of Variable Length Subarrays.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int subarraySum(int[] nums) {
+        int n = nums.length;
+        int[] prefixSum = new int[n];
+        int sum = 0;
+        int result = 0;
+        for (int i = 0; i < n; i++) {
+            sum += nums[i];
+            prefixSum[i] = sum;
+            int start = Math.max(0, i - nums[i]);
+            int subarraySum = prefixSum[i];
+            if (start > 0) {
+                subarraySum -= prefixSum[start - 1];
+            }
+            result += subarraySum;
+        }
+        return result;
+    }
+}

From d6786b2ff3c8a07e513860428dd3aabbfc08cf20 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 26 Jan 2025 12:00:18 -0800
Subject: [PATCH 2135/2175] Create Count Partitions with Even Sum
 Difference.java

---
 ...unt Partitions with Even Sum Difference.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Count Partitions with Even Sum Difference.java

diff --git a/Easy/Count Partitions with Even Sum Difference.java b/Easy/Count Partitions with Even Sum Difference.java
new file mode 100644
index 00000000..0390a5a1
--- /dev/null
+++ b/Easy/Count Partitions with Even Sum Difference.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int countPartitions(int[] nums) {
+        int n = nums.length;
+        int[] prefixSum = new int[n];
+        for (int i = 0; i < n; i++) {
+            prefixSum[i] = nums[i];
+            prefixSum[i] += i == 0 ? 0 : prefixSum[i - 1];
+        }
+        int partitions = 0;
+        for (int i = 0; i < n - 1; i++) {
+            int leftSum = prefixSum[i];
+            int rightSum = prefixSum[n - 1] - prefixSum[i];
+            partitions += (rightSum - leftSum) % 2 == 0 ? 1 : 0;
+        }
+        return partitions;
+    }
+}

From 4c9aa9825459d2daa31037fc023d74417964b321 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 31 Jan 2025 08:19:14 -0800
Subject: [PATCH 2136/2175] Create Count Mentions Per User.java

---
 Medium/Count Mentions Per User.java | 61 +++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 Medium/Count Mentions Per User.java

diff --git a/Medium/Count Mentions Per User.java b/Medium/Count Mentions Per User.java
new file mode 100644
index 00000000..7fa42668
--- /dev/null
+++ b/Medium/Count Mentions Per User.java	
@@ -0,0 +1,61 @@
+class Solution {
+    public int[] countMentions(int numberOfUsers, List<List<String>> eventLog) {
+        List<Event> events = eventLog.stream()
+            .map(Event::buildEvent)
+            .sorted()
+            .collect(Collectors.toList());
+        Map<Integer, Integer> offlineUsers = new HashMap<>();
+        int[] mentions = new int[numberOfUsers];
+        for (Event event : events) {
+            if (event.message().equals("OFFLINE")) {
+                offlineUsers.put(Integer.parseInt(event.mentionString()), event.timestamp());
+            } else {
+                int timestamp = event.timestamp();
+                List<Integer> onlineUsers = offlineUsers.entrySet()
+                    .stream()
+                    .filter(t -> timestamp - t.getValue() >= 60)
+                    .map(Map.Entry::getKey)
+                    .collect(Collectors.toList());
+                onlineUsers.forEach(offlineUsers::remove);
+                String mentionString = event.mentionString();
+                if (mentionString.equals("ALL")) {
+                    for (int i = 0; i < numberOfUsers; i++) {
+                        mentions[i]++;
+                    }
+                } else if (mentionString.equals("HERE")) {
+                    for (int i = 0; i < numberOfUsers; i++) {
+                        if (!offlineUsers.containsKey(i)) {
+                            mentions[i]++;
+                        }
+                    }
+                } else {
+                    String[] usersMentioned = mentionString.split(" ");
+                    for (String user : usersMentioned) {
+                        int userId = Integer.parseInt(user.substring(2));
+                        mentions[userId]++;
+                    }
+                }
+            }
+        }
+        return mentions;
+    }
+
+    private record Event(String message, int timestamp, String mentionString) implements Comparable<Event> {
+
+        public static Event buildEvent(List<String> event) {
+            String message = event.get(0);
+            int timestamp = Integer.parseInt(event.get(1));
+            String mentionString = event.get(2);
+            return new Event(message, timestamp, mentionString);
+        }
+
+        @Override
+        public int compareTo(Event o) {
+            int c = this.timestamp - o.timestamp;
+            if (c != 0) {
+                return c;
+            }
+            return o.message().compareTo(this.message());
+        }
+    }
+}

From d8afeb208d59a04ec1360c090fa2090b6bc5ceb3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 2 Feb 2025 10:50:47 -0800
Subject: [PATCH 2137/2175] Create Maximum Difference Between Even and Odd
 Frequency I.java

---
 ...ence Between Even and Odd Frequency I.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Easy/Maximum Difference Between Even and Odd Frequency I.java

diff --git a/Easy/Maximum Difference Between Even and Odd Frequency I.java b/Easy/Maximum Difference Between Even and Odd Frequency I.java
new file mode 100644
index 00000000..ec68c06f
--- /dev/null
+++ b/Easy/Maximum Difference Between Even and Odd Frequency I.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxDifference(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        int maxOdd = Integer.MIN_VALUE;
+        int minEven = Integer.MAX_VALUE;
+        for (Character key : map.keySet()) {
+            Integer value = map.get(key);
+            if (value % 2 == 0) {
+                minEven = Math.min(minEven, value);
+            } else {
+                maxOdd = Math.max(maxOdd, value);
+            }
+        }
+        return maxOdd - minEven;
+    }
+}

From 540318b7d9293dc1da5c063a50b6f05cd6730edc Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 3 Feb 2025 09:25:47 -0800
Subject: [PATCH 2138/2175] Create Longest Strictly Increasing or Strictly
 Decreasing Subarray.java

---
 ...asing or Strictly Decreasing Subarray.java | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java

diff --git a/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java b/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java
new file mode 100644
index 00000000..c1ed1c36
--- /dev/null
+++ b/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int longestMonotonicSubarray(int[] nums) {
+        int max = 1;
+        int idx = 0;
+        int n = nums.length;
+        while (idx < n) {
+            if (idx == n - 1 || nums[idx + 1] == nums[idx]) {
+                idx++;
+                continue;
+            }
+            boolean increase = nums[idx + 1] > nums[idx];
+            int start = idx;
+            while (idx + 1 < n && (
+                (increase && nums[idx + 1] > nums[idx]) || 
+                (!increase && nums[idx + 1] < nums[idx]))) {
+                idx++;
+            }
+            max = Math.max(max, idx - start + 1);
+        }
+        return max;
+    }
+}

From c259c7ab846d08dcc0fc9d3cd4d07ac1c901a2e6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 3 Feb 2025 17:35:11 -0800
Subject: [PATCH 2139/2175] Update Maximum Ascending Subarray Sum.java

---
 Easy/Maximum Ascending Subarray Sum.java | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/Easy/Maximum Ascending Subarray Sum.java b/Easy/Maximum Ascending Subarray Sum.java
index fb436414..fd64c04c 100644
--- a/Easy/Maximum Ascending Subarray Sum.java	
+++ b/Easy/Maximum Ascending Subarray Sum.java	
@@ -1,14 +1,15 @@
 class Solution {
-  public int maxAscendingSum(int[] nums) {
-    int maximumSum = 0;
-    int idx = 0;
-    while (idx < nums.length) {
-      int currSum = nums[idx++];
-      while (idx < nums.length && nums[idx] > nums[idx - 1]) {
-        currSum += nums[idx++];
-      }
-      maximumSum = Math.max(maximumSum, currSum);
+    public int maxAscendingSum(int[] nums) {
+        int maxSum = 0;
+        int idx = 0;
+        int n = nums.length;
+        while (idx < n) {
+            int currSum = nums[idx++];
+            while (idx < n && nums[idx] > nums[idx - 1]) {
+                currSum += nums[idx++];
+            }
+            maxSum = Math.max(maxSum, currSum);
+        }
+        return maxSum;
     }
-    return maximumSum;
-  }
 }

From d9a05d959355c1e27adb0d404872b4d3bafe5763 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 5 Feb 2025 07:54:25 -0800
Subject: [PATCH 2140/2175] Update Check if One String Swap Can Make Strings
 Equal.java

---
 ...ne String Swap Can Make Strings Equal.java | 29 +++++++++++--------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/Easy/Check if One String Swap Can Make Strings Equal.java b/Easy/Check if One String Swap Can Make Strings Equal.java
index 3f26dac9..fca6fc9d 100644
--- a/Easy/Check if One String Swap Can Make Strings Equal.java	
+++ b/Easy/Check if One String Swap Can Make Strings Equal.java	
@@ -1,16 +1,21 @@
 class Solution {
-  public boolean areAlmostEqual(String s1, String s2) {
-    int mismatchIdx = -1;
-    for (int i = 0; i < s1.length(); i++) {
-      if (s1.charAt(i) != s2.charAt(i)) {
-        if (mismatchIdx != -1) {
-          return s1.charAt(mismatchIdx) == s2.charAt(i) && 
-            s1.charAt(i) == s2.charAt(mismatchIdx) && 
-            s1.substring(i + 1).equals(s2.substring(i + 1));
+    public boolean areAlmostEqual(String s1, String s2) {
+        int swapIdx = -1;
+        boolean swapped = false;
+        for (int i = 0; i < s1.length(); i++) {
+            if (s1.charAt(i) != s2.charAt(i)) {
+                if (swapped) {
+                    return false;
+                }
+                if (swapIdx != -1) {
+                    if (!(s1.charAt(swapIdx) == s2.charAt(i) && s1.charAt(i) == s2.charAt(swapIdx))) {
+                        return false;
+                    }
+                    swapped = true;
+                } 
+                swapIdx = i;
+            }
         }
-        mismatchIdx = i;
-      }
+        return swapIdx == -1 || (swapIdx != -1 && swapped);
     }
-    return mismatchIdx == -1;
-  }
 }

From 70d1c410af8e9fb0177e1494d24adffca1d7f7cb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 7 Feb 2025 06:58:14 -0800
Subject: [PATCH 2141/2175] Create Find the Number of Distinct Colors Among the
 Balls.java

---
 ...er of Distinct Colors Among the Balls.java | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 Medium/Find the Number of Distinct Colors Among the Balls.java

diff --git a/Medium/Find the Number of Distinct Colors Among the Balls.java b/Medium/Find the Number of Distinct Colors Among the Balls.java
new file mode 100644
index 00000000..428e5406
--- /dev/null
+++ b/Medium/Find the Number of Distinct Colors Among the Balls.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int[] queryResults(int limit, int[][] queries) {
+        Map<Integer, Integer> ballToColor = new HashMap<>();
+        Map<Integer, Integer> colorToBallCount = new HashMap<>();
+        int n = queries.length;
+        int[] result = new int[n];
+        for (int i = 0; i < queries.length; i++) {
+            int ball = queries[i][0];
+            int color = queries[i][1];
+            if (ballToColor.containsKey(ball)) {
+                int prevColor = ballToColor.get(ball);
+                colorToBallCount.put(prevColor, colorToBallCount.get(prevColor) - 1);
+                if (colorToBallCount.get(prevColor) == 0) {
+                    colorToBallCount.remove(prevColor);
+                }
+            }
+            ballToColor.put(ball, color);
+            colorToBallCount.put(color, colorToBallCount.getOrDefault(color, 0) + 1);
+            result[i] = colorToBallCount.size();
+        }
+        return result;
+    }
+}

From aa8154baf0afb55c54055d44e5af4b7df0455f82 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 8 Feb 2025 11:35:50 -0800
Subject: [PATCH 2142/2175] Create Design a Number Container System.java

---
 Medium/Design a Number Container System.java | 34 ++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 Medium/Design a Number Container System.java

diff --git a/Medium/Design a Number Container System.java b/Medium/Design a Number Container System.java
new file mode 100644
index 00000000..26a3e843
--- /dev/null
+++ b/Medium/Design a Number Container System.java	
@@ -0,0 +1,34 @@
+class NumberContainers {
+
+    private final Map<Integer, TreeSet<Integer>> numberToIndex;
+    private final Map<Integer, Integer> indexToNumber;
+
+    public NumberContainers() {
+        this.numberToIndex = new HashMap<>();  
+        this.indexToNumber = new HashMap<>();      
+    }
+    
+    public void change(int index, int number) {
+        if (indexToNumber.containsKey(index)) {
+            int prevNumber = indexToNumber.get(index);
+            numberToIndex.get(prevNumber).remove(index);
+        }
+        indexToNumber.put(index, number);
+        numberToIndex.computeIfAbsent(number, k -> new TreeSet<>()).add(index);
+    }
+    
+    public int find(int number) {
+        TreeSet<Integer> indices = numberToIndex.getOrDefault(number, new TreeSet<>());
+        if (indices.isEmpty()) {
+            return -1;
+        }
+        return indices.first();
+    }
+}
+
+/**
+ * Your NumberContainers object will be instantiated and called as such:
+ * NumberContainers obj = new NumberContainers();
+ * obj.change(index,number);
+ * int param_2 = obj.find(number);
+ */

From 583c210c39e1ecb62cde8460bcd55f23f2123f66 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 11 Feb 2025 07:07:35 -0800
Subject: [PATCH 2143/2175] Update Remove All Occurrences of a Substring.java

---
 ...Remove All Occurrences of a Substring.java | 38 ++++++++++++++-----
 1 file changed, 29 insertions(+), 9 deletions(-)

diff --git a/Medium/Remove All Occurrences of a Substring.java b/Medium/Remove All Occurrences of a Substring.java
index 08fa1f78..e46ad3f2 100644
--- a/Medium/Remove All Occurrences of a Substring.java	
+++ b/Medium/Remove All Occurrences of a Substring.java	
@@ -1,12 +1,32 @@
 class Solution {
-  public String removeOccurrences(String s, String part) {
-    while (true) {
-      int idx = s.indexOf(part);
-      if (idx == -1) {
-        break;
-      }
-      s = s.substring(0, idx) + s.substring(idx + part.length());
+    public String removeOccurrences(String s, String part) {
+        Stack<Character> stack = new Stack<>();
+        int n = s.length();
+        int partLength = part.length();
+        for (int i = 0; i < n; i++) {
+            stack.push(s.charAt(i));
+            if (stack.size() >= partLength && check(stack, part, partLength)) {
+                for (int j = 0; j < partLength; j++) {
+                    stack.pop();
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
+    }
+
+    private boolean check(Stack<Character> stack, String part, int partLength) {
+        Stack<Character> temp = new Stack<>();
+        temp.addAll(stack);
+        for (int i = partLength - 1; i >= 0; i--) {
+            if (temp.isEmpty() || temp.peek() != part.charAt(i)) {
+                return false;
+            }
+            temp.pop();
+        }
+        return true;
     }
-    return s;
-  }
 }

From 2daac9d705fcc126adceb388263b9c526b9961c3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 11 Feb 2025 17:29:01 -0800
Subject: [PATCH 2144/2175] Update Max Sum of a Pair With Equal Sum of
 Digits.java

---
 ...um of a Pair With Equal Sum of Digits.java | 42 +++++++++----------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/Medium/Max Sum of a Pair With Equal Sum of Digits.java b/Medium/Max Sum of a Pair With Equal Sum of Digits.java
index 597e0658..1d8d89ae 100644
--- a/Medium/Max Sum of a Pair With Equal Sum of Digits.java	
+++ b/Medium/Max Sum of a Pair With Equal Sum of Digits.java	
@@ -1,25 +1,25 @@
 class Solution {
-  public int maximumSum(int[] nums) {
-    int maxSum = -1;
-    Map<Integer, Integer> map = new HashMap<>();
-    for (int num : nums) {
-      int digitSum = getDigitSum(num);
-      if (map.containsKey(digitSum)) {
-        maxSum = Math.max(maxSum, map.get(digitSum) + num);
-        map.put(digitSum, Math.max(map.get(digitSum), num));
-      } else {
-        map.put(digitSum, num);
-      }
+    public int maximumSum(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int maxSum = -1;
+        for (int num : nums) {
+            int digitSum = calculateDigitSum(num);
+            if (map.containsKey(digitSum)) {
+                maxSum = Math.max(maxSum, map.get(digitSum) + num);
+                map.put(digitSum, Math.max(map.get(digitSum), num));
+            } else {
+                map.put(digitSum, num);
+            }
+        }
+        return maxSum;
     }
-    return maxSum;
-  }
-  
-  private int getDigitSum(int num) {
-    int sum = 0;
-    while (num > 0) {
-      sum += num % 10;
-      num /= 10;
+
+    private int calculateDigitSum(int num) {
+        int sum = 0;
+        while (num > 0) {
+            sum += num % 10;
+            num /= 10;
+        }
+        return sum;
     }
-    return sum;
-  }
 }

From 30f21710052e766d53c921aceb97d2b09d79e4a4 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 12 Feb 2025 17:40:13 -0800
Subject: [PATCH 2145/2175] Create Minimum Operations to Exceed Threshold Value
 II.java

---
 ...Operations to Exceed Threshold Value II.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Medium/Minimum Operations to Exceed Threshold Value II.java

diff --git a/Medium/Minimum Operations to Exceed Threshold Value II.java b/Medium/Minimum Operations to Exceed Threshold Value II.java
new file mode 100644
index 00000000..9a6c2b09
--- /dev/null
+++ b/Medium/Minimum Operations to Exceed Threshold Value II.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int minOperations(int[] nums, int k) {
+        PriorityQueue<Long> pq = new PriorityQueue<>();
+        for (int num : nums) {
+            pq.add((long) num);
+        }
+        int operations = 0;
+        while (pq.peek() < k) {
+            long smallest = pq.poll();
+            long secondSmallest = pq.poll();
+            long newValue = Math.min(smallest, secondSmallest) * 2 + Math.max(smallest, secondSmallest);
+            pq.add(newValue);
+            operations++;
+        }
+        return operations;
+    }
+}

From 04175b684ba89a52fedb9b8a5ccd9989c2a21c95 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 19 Feb 2025 07:32:27 -0800
Subject: [PATCH 2146/2175] Create Construct Smallest Number From DI
 String.java

---
 .../Construct Smallest Number From DI String.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 Medium/Construct Smallest Number From DI String.java

diff --git a/Medium/Construct Smallest Number From DI String.java b/Medium/Construct Smallest Number From DI String.java
new file mode 100644
index 00000000..64e39262
--- /dev/null
+++ b/Medium/Construct Smallest Number From DI String.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public String smallestNumber(String pattern) {
+        StringBuilder result = new StringBuilder();
+        Stack<Integer> stack = new Stack<>();
+        for (int i = 0; i <= pattern.length(); i++) {
+            stack.push(i + 1);
+            if (i == pattern.length() || pattern.charAt(i) == 'I') {
+                while (!stack.isEmpty()) {
+                    result.append(stack.pop());
+                }
+            }
+        }
+        return result.toString();
+    }
+}

From 5fb999c033b967a78437f39cbb7a09fb302db94b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 19 Feb 2025 07:37:28 -0800
Subject: [PATCH 2147/2175] Create The k-th Lexicographical String of All Happy
 Strings of Length n.java

---
 ...ring of All Happy Strings of Length n.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/The k-th Lexicographical String of All Happy Strings of Length n.java

diff --git a/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java b/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java
new file mode 100644
index 00000000..413b67d5
--- /dev/null
+++ b/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java	
@@ -0,0 +1,28 @@
+class Solution {
+    private static final char[] CHARS = {'a', 'b', 'c'};
+
+    public String getHappyString(int n, int k) {
+        Set<String> set = new HashSet<>();
+        backtrack(set, new StringBuilder(), n);
+        if (set.size() < k) {
+            return "";
+        }
+        List<String> list = new ArrayList<>(set);
+        Collections.sort(list);
+        return list.get(k - 1);
+    }
+
+    private void backtrack(Set<String> set, StringBuilder sb, int n) {
+        if (sb.length() == n) {
+            set.add(sb.toString());
+            return;
+        }
+        for (char c : CHARS) {
+            if (sb.isEmpty() || sb.charAt(sb.length() - 1) != c) {
+                sb.append(c);
+                backtrack(set, sb, n);
+                sb.deleteCharAt(sb.length() - 1);
+            }
+        }
+    }
+}

From 50b0cb2ebb75524dc7241d8bc89c8c065ed739e3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 20 Feb 2025 09:03:42 -0800
Subject: [PATCH 2148/2175] Create Find Unique Binary String.java

---
 Medium/Find Unique Binary String.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Find Unique Binary String.java

diff --git a/Medium/Find Unique Binary String.java b/Medium/Find Unique Binary String.java
new file mode 100644
index 00000000..80cdfa9e
--- /dev/null
+++ b/Medium/Find Unique Binary String.java	
@@ -0,0 +1,25 @@
+class Solution {
+
+    private static final char[] BINARY_CHARS = {'1', '0'};
+
+    public String findDifferentBinaryString(String[] nums) {
+        int n = nums.length;
+        Set<String> binaryStrings = new HashSet<>();
+        backtrack(new StringBuilder(), n, binaryStrings);
+        Set<String> binaryStringsPresent = Arrays.stream(nums).collect(Collectors.toSet());
+        binaryStrings.removeAll(binaryStringsPresent);
+        return binaryStrings.isEmpty() ? "" : binaryStrings.iterator().next();
+    }
+
+    private void backtrack(StringBuilder sb, int n, Set<String> binaryStrings) {
+        if (sb.length() == n) {
+            binaryStrings.add(sb.toString());
+            return;
+        }
+        for (char c : BINARY_CHARS) {
+            sb.append(c);
+            backtrack(sb, n, binaryStrings);
+            sb.deleteCharAt(sb.length() - 1);
+        }
+    }
+}

From c1ff60a4007603b312912ca49122646f8daa8cf3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Feb 2025 07:33:11 -0800
Subject: [PATCH 2149/2175] Update Recover a Tree From Preorder Traversal.java

---
 ...ecover a Tree From Preorder Traversal.java | 56 ++++++++++---------
 1 file changed, 30 insertions(+), 26 deletions(-)

diff --git a/Hard/Recover a Tree From Preorder Traversal.java b/Hard/Recover a Tree From Preorder Traversal.java
index 69f3fe55..b851ca44 100644
--- a/Hard/Recover a Tree From Preorder Traversal.java	
+++ b/Hard/Recover a Tree From Preorder Traversal.java	
@@ -4,41 +4,45 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode recoverFromPreorder(String S) {
-        Map<Integer, TreeNode> map = new HashMap<>();
+    public TreeNode recoverFromPreorder(String traversal) {
+        Stack<TreeNode> stack = new Stack<>();
         int idx = 0;
-        int n = S.length();
-
-        while (idx < n) {
-            int level = 0;
-            StringBuilder sb = new StringBuilder();
-
-            while (idx < n && S.charAt(idx) == '-') {
-                level++;
+        while (idx < traversal.length()) {
+            int depth = 0;
+            while (idx < traversal.length() && traversal.charAt(idx) == '-') {
+                depth++;
                 idx++;
             }
-
-            while (idx < n && Character.isDigit(S.charAt(idx))) {
-                sb.append(S.charAt(idx++));
+            int value = 0;
+            while (idx < traversal.length() && Character.isDigit(traversal.charAt(idx))) {
+                value = value * 10 + Character.getNumericValue(traversal.charAt(idx++));
             }
-
-            TreeNode currNode = new TreeNode(Integer.parseInt(sb.toString()));
-            map.put(level, currNode);
-            if (level > 0) {
-                TreeNode parent = map.get(level - 1);
-                if (parent.left == null) {
-                    parent.left = currNode;
-                }
-                else {
-                    parent.right = currNode;
+            TreeNode node = new TreeNode(value);
+            while (stack.size() > depth) {
+                stack.pop();
+            }
+            if (!stack.isEmpty()) {
+                if (stack.peek().left == null) {
+                    stack.peek().left = node;
+                } else {
+                    stack.peek().right = node;
                 }
             }
+            stack.push(node);
+        }
+        while (stack.size() > 1) {
+            stack.pop();
         }
-
-        return map.get(0);
+        return stack.peek();
     }
 }

From c25f01b2f86ae67c45d919b9174559184e163564 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 Feb 2025 10:38:59 -0800
Subject: [PATCH 2150/2175] Create Construct Binary Tree from Preorder and
 Postorder Traversal.java

---
 ...from Preorder and Postorder Traversal.java | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 Medium/Construct Binary Tree from Preorder and Postorder Traversal.java

diff --git a/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java b/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java
new file mode 100644
index 00000000..ca7aa35d
--- /dev/null
+++ b/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java	
@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
+        int n = preorder.length;
+        Map<Integer, Integer> postorderIndex = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            postorderIndex.put(postorder[i], i);
+        }
+        return constructTree(0, n - 1, 0, preorder, postorderIndex);
+    }
+
+    private TreeNode constructTree(int preStart, int preEnd, int postStart, int[] preorder, Map<Integer, Integer> postorderIndex) {
+        if (preStart > preEnd) {
+            return null;
+        }
+        if (preStart == preEnd) {
+            return new TreeNode(preorder[preStart]);
+        }
+        int leftRoot = preorder[preStart + 1];
+        int leftCount = postorderIndex.get(leftRoot) - postStart + 1;
+        TreeNode root = new TreeNode(preorder[preStart]);
+        root.left = constructTree(preStart + 1, preStart + leftCount, postStart, preorder, postorderIndex);
+        root.right = constructTree(preStart + leftCount + 1, preEnd, postStart + leftCount, preorder, postorderIndex);
+        return root;
+    }
+}

From 88ecb654b06441c1414888c2b0994fa092cd693e Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 1 Mar 2025 09:10:57 -0800
Subject: [PATCH 2151/2175] Update Apply Operations to an Array.java

---
 Easy/Apply Operations to an Array.java | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/Easy/Apply Operations to an Array.java b/Easy/Apply Operations to an Array.java
index b0a663a2..3b2bca86 100644
--- a/Easy/Apply Operations to an Array.java	
+++ b/Easy/Apply Operations to an Array.java	
@@ -1,21 +1,20 @@
 class Solution {
     public int[] applyOperations(int[] nums) {
-        for (int i = 0; i < nums.length - 1; i++) {
+        int n = nums.length;
+        for (int i = 0; i < n - 1; i++) {
             if (nums[i] == nums[i + 1]) {
                 nums[i] *= 2;
                 nums[i + 1] = 0;
             }
         }
-        int startIdx = 0;
-        int endIdx = 0;
-        while (endIdx < nums.length) {
-            if (nums[endIdx] != 0) {
-                nums[startIdx++] = nums[endIdx];
+        int start = 0;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] != 0) {
+                nums[start++] = nums[i];
             }
-            endIdx++;
         }
-        while (startIdx < nums.length) {
-            nums[startIdx++] = 0;
+        while (start < n) {
+            nums[start++] = 0;
         }
         return nums;
     }

From 7e86b13cd7f4381cde89fb4c4302b48cd9ca336b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 5 Mar 2025 09:49:51 -0800
Subject: [PATCH 2152/2175] Create Count Total Number of Colored Cells.java

---
 Medium/Count Total Number of Colored Cells.java | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 Medium/Count Total Number of Colored Cells.java

diff --git a/Medium/Count Total Number of Colored Cells.java b/Medium/Count Total Number of Colored Cells.java
new file mode 100644
index 00000000..81c10a8c
--- /dev/null
+++ b/Medium/Count Total Number of Colored Cells.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public long coloredCells(int n) {
+        long count = 1;
+        int increment = 4;
+        while (n-- > 1) {
+            count += increment;
+            increment += 4;
+        }
+        return count;
+    }
+}

From 72f877e6ebf35519842c65e03815c4a3ae74274c Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 9 Mar 2025 12:03:46 -0700
Subject: [PATCH 2153/2175] Create Fruits Into Baskets II.java

---
 Easy/Fruits Into Baskets II.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 Easy/Fruits Into Baskets II.java

diff --git a/Easy/Fruits Into Baskets II.java b/Easy/Fruits Into Baskets II.java
new file mode 100644
index 00000000..e0afa848
--- /dev/null
+++ b/Easy/Fruits Into Baskets II.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
+        int count = 0;
+        for (int fruit : fruits) {
+            int idx = -1;
+            for (int i = 0; i < baskets.length; i++) {
+                if (baskets[i] >= fruit) {
+                    idx = i;
+                    break;
+                }
+            }
+            if (idx == -1) {
+                count++;
+            } else {
+                baskets[idx] = -1;
+            }
+        }
+        return count;
+    }
+}

From 8ed8a35ed86218a68f9211ab2c2495a20c951a68 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 19 Mar 2025 06:48:37 -0700
Subject: [PATCH 2154/2175] Create Maximum Unique Subarray Sum After
 Deletion.java

---
 ...imum Unique Subarray Sum After Deletion.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Maximum Unique Subarray Sum After Deletion.java

diff --git a/Easy/Maximum Unique Subarray Sum After Deletion.java b/Easy/Maximum Unique Subarray Sum After Deletion.java
new file mode 100644
index 00000000..e0a6a2ae
--- /dev/null
+++ b/Easy/Maximum Unique Subarray Sum After Deletion.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxSum(int[] nums) {
+        int max = nums[0];
+        int sum = 0;
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            max = Math.max(num, max);
+            if (num > 0 && set.add(num)) {
+                sum += num;
+            }
+        }
+        if (max < 0) {
+            return max;
+        }
+        return sum;
+    }
+}

From f70a266f0ed726909b5228b54184c48081e4b6ee Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 20 Mar 2025 07:48:37 -0700
Subject: [PATCH 2155/2175] Create Design Spreadsheet.java

---
 Medium/Design Spreadsheet.java | 47 ++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 Medium/Design Spreadsheet.java

diff --git a/Medium/Design Spreadsheet.java b/Medium/Design Spreadsheet.java
new file mode 100644
index 00000000..e41fc142
--- /dev/null
+++ b/Medium/Design Spreadsheet.java	
@@ -0,0 +1,47 @@
+class Spreadsheet {
+
+    private final Map<Character, Map<Integer, Integer>> sheet;
+
+    public Spreadsheet(int rows) {
+        sheet = new HashMap<>();
+        for (char c = 'A'; c <= 'Z'; c++) {
+            sheet.put(c, new HashMap<>());
+        }
+    }
+    
+    public void setCell(String cell, int value) {
+        char column = cell.charAt(0);
+        int rowNumber = Integer.parseInt(cell.substring(1));
+        Map<Integer, Integer> row = sheet.get(column);
+        row.put(rowNumber, value);
+    }
+    
+    public void resetCell(String cell) {
+        setCell(cell, 0);
+    }
+    
+    public int getValue(String formula) {
+        String[] split = formula.split("\\+");
+        String cellOne = split[0].substring(1);
+        String cellTwo = split[1];
+        return getCellValue(cellOne) + getCellValue(cellTwo);
+    }
+
+    private int getCellValue(String cell) {
+        if (!Character.isLetter(cell.charAt(0))) {
+            return Integer.parseInt(cell);
+        }
+        char column = cell.charAt(0);
+        int rowNumber = Integer.parseInt(cell.substring(1));
+        Map<Integer, Integer> row = sheet.get(column);
+        return row.getOrDefault(rowNumber, 0);
+    }
+}
+
+/**
+ * Your Spreadsheet object will be instantiated and called as such:
+ * Spreadsheet obj = new Spreadsheet(rows);
+ * obj.setCell(cell,value);
+ * obj.resetCell(cell);
+ * int param_3 = obj.getValue(formula);
+ */

From 79fab170a7e6dbe64afb009018de192c97e49dc2 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 22 Mar 2025 16:51:49 -0700
Subject: [PATCH 2156/2175] Create Count the Number of Complete Components.java

---
 ...unt the Number of Complete Components.java | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Medium/Count the Number of Complete Components.java

diff --git a/Medium/Count the Number of Complete Components.java b/Medium/Count the Number of Complete Components.java
new file mode 100644
index 00000000..d198b0b2
--- /dev/null
+++ b/Medium/Count the Number of Complete Components.java	
@@ -0,0 +1,38 @@
+class Solution {
+    public int countCompleteComponents(int n, int[][] edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            int nodeOne = edge[0];
+            int nodeTwo = edge[1];
+            graph.computeIfAbsent(nodeOne, k -> new HashSet<>()).add(nodeTwo);
+            graph.computeIfAbsent(nodeTwo, k -> new HashSet<>()).add(nodeOne);
+        }
+        int count = 0;
+        Set<Integer> visited = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            if (visited.add(i)) {
+                int[] componentInfo = new int[2];
+                dfs(i, graph, visited, componentInfo);
+                if (componentInfo[0] * (componentInfo[0] - 1) == componentInfo[1]) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    private void dfs(
+        int node, 
+        Map<Integer, Set<Integer>> graph, 
+        Set<Integer> visited, 
+        int[] componentInfo) {
+        componentInfo[0]++;
+        Set<Integer> connections = graph.getOrDefault(node, new HashSet<>());
+        componentInfo[1] += connections.size();
+        for (Integer conn : connections) {
+            if (visited.add(conn)) {
+                dfs(conn, graph, visited, componentInfo);
+            }
+        }
+    }
+}

From f09b6a6dcfc4bbd1cb3fe614078cd8141ac05a02 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 23 Mar 2025 08:14:49 -0700
Subject: [PATCH 2157/2175] Create Maximum Containers on a Ship.java

---
 Easy/Maximum Containers on a Ship.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Easy/Maximum Containers on a Ship.java

diff --git a/Easy/Maximum Containers on a Ship.java b/Easy/Maximum Containers on a Ship.java
new file mode 100644
index 00000000..e113027d
--- /dev/null
+++ b/Easy/Maximum Containers on a Ship.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int maxContainers(int n, int w, int maxWeight) {
+        if (n * n * w <= maxWeight) {
+            return n * n;
+        }
+        return maxWeight / w;
+    }
+}

From 0343dfd31a1cc8309b3ea10ed1315c1287b594c5 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 29 Mar 2025 08:02:00 -0700
Subject: [PATCH 2158/2175] Create Count Days Without Meetings.java

---
 Medium/Count Days Without Meetings.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Count Days Without Meetings.java

diff --git a/Medium/Count Days Without Meetings.java b/Medium/Count Days Without Meetings.java
new file mode 100644
index 00000000..1630e6df
--- /dev/null
+++ b/Medium/Count Days Without Meetings.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int countDays(int days, int[][] meetings) {
+        Arrays.sort(meetings, (o1, o2) -> {
+            int c = Integer.compare(o1[0], o2[0]);
+            if (c != 0) {
+                return c;
+            }
+            return Integer.compare(o2[1], o1[1]);
+        });
+        int meetingDays = 0;
+        int idx = 0;
+        while (idx < meetings.length) {
+            int start = meetings[idx][0];
+            int end = meetings[idx][1];
+            idx++;
+            while (idx < meetings.length && meetings[idx][0] <= end) {
+                end = Math.max(end, meetings[idx][1]);
+                idx++;
+            }
+            meetingDays += (end - start + 1);
+        }
+        return days - meetingDays;
+    }
+}

From e6687a6c142a52bdee850192a39b13c70a8e6785 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Mar 2025 07:04:57 -0700
Subject: [PATCH 2159/2175] Create Reverse Degree of a String.java

---
 Easy/Reverse Degree of a String.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Reverse Degree of a String.java

diff --git a/Easy/Reverse Degree of a String.java b/Easy/Reverse Degree of a String.java
new file mode 100644
index 00000000..db8f4e91
--- /dev/null
+++ b/Easy/Reverse Degree of a String.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public int reverseDegree(String s) {
+        int result = 0;
+        for (int i = 0; i < s.length(); i++) {
+            result += (i + 1) * (26 - (s.charAt(i) - 'a'));
+        }
+        return result;
+    }
+}

From 6c82d5e37dfb702b58b177185123e545799b0b3f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 30 Mar 2025 07:15:26 -0700
Subject: [PATCH 2160/2175] Create Minimum Cost to Reach Every Position.java

---
 Easy/Minimum Cost to Reach Every Position.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Easy/Minimum Cost to Reach Every Position.java

diff --git a/Easy/Minimum Cost to Reach Every Position.java b/Easy/Minimum Cost to Reach Every Position.java
new file mode 100644
index 00000000..1b142d2c
--- /dev/null
+++ b/Easy/Minimum Cost to Reach Every Position.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int[] minCosts(int[] cost) {
+        int n = cost.length;
+        int[] result = new int[n];
+        int minCost = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            int curr = cost[i];
+            minCost = Math.min(minCost, curr);
+            result[i] = minCost;
+        }
+        return result;
+    }
+}

From d607cf25ba1d4a4f13c5a7a8ad2e709571352bbe Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Apr 2025 11:12:22 -0700
Subject: [PATCH 2161/2175] Create Find Closest Person.java

---
 Easy/Find Closest Person.java | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Easy/Find Closest Person.java

diff --git a/Easy/Find Closest Person.java b/Easy/Find Closest Person.java
new file mode 100644
index 00000000..0d178230
--- /dev/null
+++ b/Easy/Find Closest Person.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int findClosest(int x, int y, int z) {
+        int diffOne = Math.abs(x - z);
+        int diffTwo = Math.abs(y - z);
+        return diffOne == diffTwo ? 0 : (diffOne < diffTwo ? 1 : 2);
+    }
+}

From f0117cca3526851eaf7192572f6ba92415fbddac Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sun, 13 Apr 2025 11:13:49 -0700
Subject: [PATCH 2162/2175] Create Minimum Operations to Make Array Sum
 Divisible by K.java

---
 ...imum Operations to Make Array Sum Divisible by K.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 Easy/Minimum Operations to Make Array Sum Divisible by K.java

diff --git a/Easy/Minimum Operations to Make Array Sum Divisible by K.java b/Easy/Minimum Operations to Make Array Sum Divisible by K.java
new file mode 100644
index 00000000..c941b50a
--- /dev/null
+++ b/Easy/Minimum Operations to Make Array Sum Divisible by K.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public int minOperations(int[] nums, int k) {
+        int sum = 0;  
+        for (int num : nums) {
+            sum += num;
+        }
+        return sum % k;
+    }
+}

From 4a81fa982c607d1d900c5f988599219cc82e8ad3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 15 Apr 2025 07:17:29 -0700
Subject: [PATCH 2163/2175] Update Count Symmetric Integers.java

---
 Easy/Count Symmetric Integers.java | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/Easy/Count Symmetric Integers.java b/Easy/Count Symmetric Integers.java
index f32301e1..8ae9c320 100644
--- a/Easy/Count Symmetric Integers.java	
+++ b/Easy/Count Symmetric Integers.java	
@@ -1,17 +1,27 @@
 class Solution {
     public int countSymmetricIntegers(int low, int high) {
-        int result = 0;
+        int count = 0;
         for (int i = low; i <= high; i++) {
-            String s = String.valueOf(i);
-            int diff = 0;
-            int n = s.length();
-            for (int j = 0; j < n / 2; j++) {
-                diff += s.charAt(j) - s.charAt(n - j - 1);
-            }
-            if (n % 2 == 0 && diff == 0) {
-                result++;
+            if (isSymmetric(i)) {
+                count++;
             }
         }
-        return result;
+        return count;
+    }
+
+    private static boolean isSymmetric(int num) {
+        String s = String.valueOf(num);
+        int n = s.length();
+        if (n % 2 != 0) {
+            return false;
+        }
+        int sum = 0;
+        for (int i = 0; i < n / 2; i++) {
+            sum += Character.getNumericValue(s.charAt(i));
+        }
+        for (int i = n / 2; i < n; i++) {
+            sum -= Character.getNumericValue(s.charAt(i));
+        }
+        return sum == 0;
     }
 }

From f37ed97923b5e909813df92781a15828b1386986 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 26 Apr 2025 08:55:01 -0700
Subject: [PATCH 2164/2175] Create Calculate Score After Performing
 Instructions.java

---
 ...e Score After Performing Instructions.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 Medium/Calculate Score After Performing Instructions.java

diff --git a/Medium/Calculate Score After Performing Instructions.java b/Medium/Calculate Score After Performing Instructions.java
new file mode 100644
index 00000000..789e5669
--- /dev/null
+++ b/Medium/Calculate Score After Performing Instructions.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public long calculateScore(String[] instructions, int[] values) {
+        long result = 0;
+        int n = values.length;
+        int idx = 0;
+        Set<Integer> executed = new HashSet<>();
+        while (idx < n && idx >= 0) {
+            if (!executed.add(idx)) {
+                break;
+            }
+            if (instructions[idx].equals("add")) {
+                result += values[idx++];
+            } else {
+                idx += values[idx];
+            }
+        }
+        return result;
+    }
+}

From 96a5d01cded0218a8c4c9e97d1fd5230ce1e23ef Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 7 May 2025 06:01:01 -0700
Subject: [PATCH 2165/2175] Create Find Minimum Time to Reach Last Room I.java

---
 ...ind Minimum Time to Reach Last Room I.java | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 Medium/Find Minimum Time to Reach Last Room I.java

diff --git a/Medium/Find Minimum Time to Reach Last Room I.java b/Medium/Find Minimum Time to Reach Last Room I.java
new file mode 100644
index 00000000..0247baa4
--- /dev/null
+++ b/Medium/Find Minimum Time to Reach Last Room I.java	
@@ -0,0 +1,36 @@
+class Solution {
+
+    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+    public int minTimeToReach(int[][] moveTime) {
+        int n = moveTime.length;
+        int m = moveTime[0].length;
+        boolean[][] visited = new boolean[n][m];
+        Integer[][] minTime = new Integer[n][m];
+        minTime[0][0] = 0;
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
+        pq.add(new int[]{0, 0, 0});
+        while (!pq.isEmpty()) {
+            int[] removed = pq.remove();
+            int x = removed[0];
+            int y = removed[1];
+            if (visited[x][y]) {
+                continue;
+            }
+            visited[x][y] = true;
+            for (int[] dir : DIRS) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                if (newX >= 0 && newY >= 0 && newX < n && newY < m) {
+                    int distance = Math.max(minTime[x][y], moveTime[newX][newY]) + 1;
+                    int currMinTime = minTime[newX][newY] == null ? Integer.MAX_VALUE : minTime[newX][newY];
+                    if (currMinTime > distance) {
+                        minTime[newX][newY] = distance;
+                        pq.add(new int[]{newX, newY, distance});
+                    }
+                }
+            }
+        }
+        return minTime[n - 1][m - 1];
+    }
+}

From c7c43dc18b8be8ebbc54ebd7a1f528e83aab85eb Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 8 May 2025 07:06:50 -0700
Subject: [PATCH 2166/2175] Create Maximum Product of Two Digits.java

---
 Easy/Maximum Product of Two Digits.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Easy/Maximum Product of Two Digits.java

diff --git a/Easy/Maximum Product of Two Digits.java b/Easy/Maximum Product of Two Digits.java
new file mode 100644
index 00000000..c61f3c3a
--- /dev/null
+++ b/Easy/Maximum Product of Two Digits.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxProduct(int n) {
+        int maximum = Integer.MIN_VALUE;
+        int secondMaximum = Integer.MIN_VALUE;
+        while (n > 0) {
+            int num = n % 10;
+            n /= 10;
+            if (num > maximum) {
+                secondMaximum = maximum;
+                maximum = num;
+            } else if (num > secondMaximum) {
+                secondMaximum = num;
+            }
+        }
+        return maximum * secondMaximum;
+    }
+}

From 0209afb33cd40797aa03707328030e2b0a8d9f5f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 14 May 2025 06:24:41 -0700
Subject: [PATCH 2167/2175] Create Total Characters in String After
 Transformations I.java

---
 ...ers in String After Transformations I.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Medium/Total Characters in String After Transformations I.java

diff --git a/Medium/Total Characters in String After Transformations I.java b/Medium/Total Characters in String After Transformations I.java
new file mode 100644
index 00000000..3751ab7e
--- /dev/null
+++ b/Medium/Total Characters in String After Transformations I.java	
@@ -0,0 +1,25 @@
+class Solution {
+
+    private static final int MOD = 1000_0000_07;
+
+    public int lengthAfterTransformations(String s, int t) {
+        int[] frequency = new int[26];
+        for (char c : s.toCharArray()) {
+            frequency[c - 'a']++;
+        }
+        for (int round = 0; round < t; round++) {
+            int[] next = new int[26];
+            next[0] = frequency[25]; // Transformation from 'z'
+            next[1] = (frequency[25] + frequency[0]) % MOD; // Transformation from either 'z' or 'a'
+            for (int i = 2; i < 26; i++) {
+                next[i] = frequency[i - 1]; // Transformation for next character
+            }
+            frequency = next;
+        }
+        int result = 0;
+        for (int i = 0; i < 26; i++) {
+            result = (result + frequency[i]) % MOD;
+        }
+        return result;
+    }
+}

From 52620f41b903dc8c26ca32aa1e7877eec199dd8b Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 20 May 2025 07:15:08 -0700
Subject: [PATCH 2168/2175] Create Zero Array Transformation I.java

---
 Medium/Zero Array Transformation I.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Medium/Zero Array Transformation I.java

diff --git a/Medium/Zero Array Transformation I.java b/Medium/Zero Array Transformation I.java
new file mode 100644
index 00000000..2b9ab602
--- /dev/null
+++ b/Medium/Zero Array Transformation I.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public boolean isZeroArray(int[] nums, int[][] queries) {
+        int n = nums.length;
+        int[] diff = new int[n + 1];
+        for (int[] query : queries) {
+            int left = query[0];
+            int right = query[1];
+            diff[left] += 1;
+            diff[right + 1] -= 1;
+        }
+        int[] operation = new int[n + 1];
+        int currOperation = 0;
+        for (int i = 0; i < n + 1; i++) {
+            currOperation += diff[i];
+            operation[i] = currOperation;
+        }
+        for (int i = 0; i < n; i++) {
+            if (operation[i] < nums[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From 96489b1a30e6f271468b065dd0d439aaef04e679 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Mon, 2 Jun 2025 07:06:56 -0700
Subject: [PATCH 2169/2175] Create Distribute Candies Among Children II.java

---
 Medium/Distribute Candies Among Children II.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Medium/Distribute Candies Among Children II.java

diff --git a/Medium/Distribute Candies Among Children II.java b/Medium/Distribute Candies Among Children II.java
new file mode 100644
index 00000000..aa9648f2
--- /dev/null
+++ b/Medium/Distribute Candies Among Children II.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public long distributeCandies(int n, int limit) {
+        long result = 0;
+        for (int i = 0; i <= Math.min(limit, n); i++) {
+            // distribution not possible as we will have to allocate at least one child with 
+            // more than limit candies
+            if (n - i > 2 * limit) {
+                continue;
+            }
+            result += Math.min(n - i, limit) - Math.max(0, n - i - limit) + 1;
+        }
+        return result;
+    }
+}

From 78832b33f37b1fc3b850ec08f957e069868ae80f Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 Jun 2025 07:21:58 -0700
Subject: [PATCH 2170/2175] Create Find Minimum Log Transportation Cost.java

---
 Easy/Find Minimum Log Transportation Cost.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Easy/Find Minimum Log Transportation Cost.java

diff --git a/Easy/Find Minimum Log Transportation Cost.java b/Easy/Find Minimum Log Transportation Cost.java
new file mode 100644
index 00000000..3820474e
--- /dev/null
+++ b/Easy/Find Minimum Log Transportation Cost.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public long minCuttingCost(int n, int m, int k) {
+        long cost = 0;
+        if (n > k) {
+            cost += ((long) (n - k)) * (k);
+        }
+        if (m > k) {
+            cost += ((long) (m - k)) * (k);
+        }
+        return cost;
+    }
+}

From a15f0c915355221f247be1e23057c46a10ad29e7 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Tue, 3 Jun 2025 07:30:09 -0700
Subject: [PATCH 2171/2175] Create Resulting String After Adjacent
 Removals.java

---
 ...ulting String After Adjacent Removals.java | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 Medium/Resulting String After Adjacent Removals.java

diff --git a/Medium/Resulting String After Adjacent Removals.java b/Medium/Resulting String After Adjacent Removals.java
new file mode 100644
index 00000000..efa43bf6
--- /dev/null
+++ b/Medium/Resulting String After Adjacent Removals.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public String resultingString(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && isAdjacent(stack.peek(), c)) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder result = new StringBuilder();
+        for (char c : stack) {
+            result.append(c);
+        }
+        return result.toString();
+    }
+
+    private static boolean isAdjacent(char first, char second) {
+        return Math.abs(first - second) == 1 || (first == 'a' && second == 'z') || (first == 'z' && second == 'a');
+    }
+}

From 89afcc3436620718196217d9f17e04054350c692 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Wed, 4 Jun 2025 10:06:43 -0700
Subject: [PATCH 2172/2175] Create Find the Lexicographically Largest String
 From the Box I.java

---
 ...raphically Largest String From the Box I.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 Medium/Find the Lexicographically Largest String From the Box I.java

diff --git a/Medium/Find the Lexicographically Largest String From the Box I.java b/Medium/Find the Lexicographically Largest String From the Box I.java
new file mode 100644
index 00000000..1133cb93
--- /dev/null
+++ b/Medium/Find the Lexicographically Largest String From the Box I.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public String answerString(String word, int numFriends) {
+        if (numFriends == 1) {
+            return word;
+        }
+        int n = word.length();
+        String result = "";
+        for (int i = 0; i < n; i++) {
+            String curr = word.substring(i, Math.min(i + n - numFriends + 1, n));
+            if (result.compareTo(curr) <= 0) {
+                result = curr;
+            }
+        }
+        return result;
+    }
+}

From b962419d92bbd2d824f9c3a624416d0ff4ed6ff6 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Thu, 5 Jun 2025 06:20:55 -0700
Subject: [PATCH 2173/2175] Update Lexicographically Smallest Equivalent
 String.java

---
 ...raphically Smallest Equivalent String.java | 69 +++++++++++--------
 1 file changed, 42 insertions(+), 27 deletions(-)

diff --git a/Medium/Lexicographically Smallest Equivalent String.java b/Medium/Lexicographically Smallest Equivalent String.java
index c5856615..f4d01c21 100644
--- a/Medium/Lexicographically Smallest Equivalent String.java	
+++ b/Medium/Lexicographically Smallest Equivalent String.java	
@@ -1,31 +1,46 @@
 class Solution {
-  public String smallestEquivalentString(String s1, String s2, String baseStr) {
-    int[] graph = new int[26];
-    for (int i = 0; i < 26; i++) {
-      graph[i] = i;
+    public String smallestEquivalentString(String s1, String s2, String baseStr) {
+        UnionFind unionFind = new UnionFind(26);
+        for (int i = 0; i < s1.length(); i++) {
+            char c1 = s1.charAt(i);
+            char c2 = s2.charAt(i);
+            unionFind.union(c1 - 'a', c2 - 'a');
+        }
+        StringBuilder result = new StringBuilder();
+        for (char c : baseStr.toCharArray()) {
+            result.append((char) (unionFind.find(c - 'a') + 'a'));
+        }
+        return result.toString();
     }
-    for (int i = 0; i < s1.length(); i++) {
-      int idxOne = s1.charAt(i) - 'a';
-      int idxTwo = s2.charAt(i) - 'a';
-      int parentOne = find(graph, idxOne);
-      int parentTwo = find(graph, idxTwo);
-      if(parentOne < parentTwo) {
-        graph[parentTwo] = parentOne;
-      } else {
-        graph[parentOne] = parentTwo;
-      }
+
+    class UnionFind {
+        private int[] parent;
+
+        public UnionFind(int n) {
+            parent = new int[n];
+            for (int i = 0; i < n; i++) {
+                parent[i] = i;
+            }
+        }
+
+        public int find(int node) {
+            if (parent[node] == node) {
+                return node;
+            }
+            parent[node] = find(parent[node]);
+            return parent[node];
+        }
+
+        public void union(int nodeOne, int nodeTwo) {
+            int parentOne = find(nodeOne);
+            int parentTwo = find(nodeTwo);
+            if (parentOne != parentTwo) {
+                if (parentOne < parentTwo) {
+                    parent[parentTwo] = parentOne;
+                } else {
+                    parent[parentOne] = parentTwo;
+                }
+            }
+        }
     }
-    StringBuilder sb = new StringBuilder();
-    for (char c : baseStr.toCharArray()) {
-      sb.append((char) ('a' + find(graph, c - 'a')));
-    }
-    return sb.toString();
-  }
-  
-  private int find(int[] graph, int idx) {
-    while(graph[idx] != idx) {
-      idx = graph[idx];
-    }
-    return idx;
-  }
 }

From da789bdd18417daf8dae61d377cfcd0b751d9ad3 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Fri, 6 Jun 2025 10:27:44 -0700
Subject: [PATCH 2174/2175] Create Using a Robot to Print the Lexicographically
 Smallest String.java

---
 ...the Lexicographically Smallest String.java | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Medium/Using a Robot to Print the Lexicographically Smallest String.java

diff --git a/Medium/Using a Robot to Print the Lexicographically Smallest String.java b/Medium/Using a Robot to Print the Lexicographically Smallest String.java
new file mode 100644
index 00000000..8d9c2064
--- /dev/null
+++ b/Medium/Using a Robot to Print the Lexicographically Smallest String.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public String robotWithString(String s) {
+        int[] counter = new int[26];
+        for (char c : s.toCharArray()) {
+            counter[c - 'a']++;
+        }
+        Stack<Character> stack = new Stack<>();
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            stack.push(c);
+            counter[c - 'a']--;
+            while (!stack.isEmpty() && isSmallest(stack.peek(), counter)) {
+                sb.append(stack.pop());
+            }
+        }
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.toString();
+    }
+
+    private boolean isSmallest(char c, int[] counter) {
+        int limit = c - 'a';
+        for (int i = 0; i < limit; i++) {
+            if (counter[i] > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

From c91e3403fb904d4f4a127e339adb252849377872 Mon Sep 17 00:00:00 2001
From: Varun Upadhyay <varun.u28@gmail.com>
Date: Sat, 7 Jun 2025 06:22:41 -0700
Subject: [PATCH 2175/2175] Create Lexicographically Minimum String After
 Removing Stars.java

---
 ...y Minimum String After Removing Stars.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 Medium/Lexicographically Minimum String After Removing Stars.java

diff --git a/Medium/Lexicographically Minimum String After Removing Stars.java b/Medium/Lexicographically Minimum String After Removing Stars.java
new file mode 100644
index 00000000..794ee712
--- /dev/null
+++ b/Medium/Lexicographically Minimum String After Removing Stars.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public String clearStars(String s) {
+        Deque<Integer>[] count = new Deque[26];
+        for (int i = 0; i < 26; i++) {
+            count[i] = new ArrayDeque<>();
+        }
+        char[] letters = s.toCharArray();
+        for (int i = 0; i < letters.length; i++) {
+            if (letters[i] != '*') {
+                count[letters[i] - 'a'].push(i);
+            } else {
+                for (int j = 0; j < 26; j++) {
+                    if (!count[j].isEmpty()) {
+                        letters[count[j].pop()] = '*';
+                        break;
+                    }
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char c : letters) {
+            if (c != '*') {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+}