Solution is Added by anjha

Author: anjha1

0890.find-and-replace-pattern/FindAndReplacePattern.java

@@ -0,0 +1,22 @@
+import java.util.LinkedList;
+import java.util.List;
+
+class FindAndReplacePattern {
+    public List<String> findAndReplacePattern(String[] words, String pattern) {
+        List<String> ans = new LinkedList<>();
+        for (String w : words) {
+            int[] p = new int[26], s = new int[26];
+            boolean same = true;
+            for (int i = 0; i < w.length(); i++) {
+                if (s[w.charAt(i) - 'a'] != p[pattern.charAt(i) - 'a']) {
+                    same = false;
+                    break;
+                } else {
+                    s[w.charAt(i) - 'a'] = p[pattern.charAt(i) - 'a'] = i + 1;
+                }
+            }
+            if (same) ans.add(w);
+        }
+        return ans;
+    }
+}

0890.find-and-replace-pattern/README.md

@@ -0,0 +1,2 @@
+# [890. Find and Replace Pattern](https://leetcode.com/problems/find-and-replace-pattern/)
+

0901.online-stock-span/OnlineStockSpan.java

@@ -0,0 +1,24 @@
+import java.util.Stack;
+
+class StockSpanner {
+    Stack<int[]> stack = new Stack<>();
+
+    public StockSpanner() {
+
+    }
+    
+    public int next(int price) {
+        int res = 1;
+        while (!stack.isEmpty() && stack.peek()[0] <= price) {
+            res += stack.pop()[1];
+        }
+        stack.push(new int[]{price, res});
+        return res;
+    }
+}
+
+/**
+ * Your StockSpanner object will be instantiated and called as such:
+ * StockSpanner obj = new StockSpanner();
+ * int param_1 = obj.next(price);
+ */

0901.online-stock-span/README.md

@@ -0,0 +1,2 @@
+# [901. Online Stock Span](https://leetcode.com/problems/online-stock-span/)
+

0904.fruit-into-baskets/FruitIntoBaskets.java

@@ -0,0 +1,22 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class FruitIntoBaskets {
+    public int totalFruit(int[] fruits) {
+        int n = fruits.length;
+        Map<Integer, Integer> cnt = new HashMap<>();
+
+        int left = 0, res = 0;
+        for (int right = 0; right < n; right++) {
+            cnt.put(fruits[right], cnt.getOrDefault(fruits[right], 0) + 1);
+            while (cnt.size() > 2) {
+                cnt.put(fruits[left], cnt.get(fruits[left]) - 1);
+                if (cnt.get(fruits[left]) == 0)
+                    cnt.remove(fruits[left]);
+                left++;
+            }
+            res = Math.max(res, right - left + 1);
+        }
+        return res;
+    }
+}

0904.fruit-into-baskets/README.md

@@ -0,0 +1,8 @@
+# [904. Fruit Into Baskets](https://leetcode.com/problems/fruit-into-baskets/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `fruits`.
+- Space Complexity: $O(1)$. Hash map only has three key value pairs in maximum, so the total space complexity is constant.

0907.sum-of-subarray-minimums/README.md

@@ -0,0 +1,2 @@
+# [907. Sum of Subarray Minimums](https://leetcode.com/problems/sum-of-subarray-minimums/)
+

0907.sum-of-subarray-minimums/SumOfSubarrayMinimums.java

@@ -0,0 +1,25 @@
+import java.util.Stack;
+
+class SumOfSubarrayMinimums {
+    private final int modulo = (int) (Math.pow(10, 9) + 7);
+
+    public int sumSubarrayMins(int[] arr) {
+        Stack<Integer> stack = new Stack<>();
+        long sumOfMinimums = 0;
+
+        for (int i = 0; i <= arr.length; i++) {
+            while (!stack.empty() && (i == arr.length || arr[stack.peek()] >= arr[i])) {
+                int mid = stack.pop();
+                int leftBoundary = stack.empty() ? -1 : stack.peek();
+                int rightBoundary = i;
+
+                long count = (long) (mid - leftBoundary) * (rightBoundary - mid) % modulo;
+                sumOfMinimums += (count * arr[mid]) % modulo;
+                sumOfMinimums %= modulo;
+            }
+            stack.push(i);
+        }
+
+        return (int) sumOfMinimums;
+    }
+}

0912.sort-an-array/README.md

@@ -0,0 +1,8 @@
+# [912. Sort an Array](https://leetcode.com/problems/sort-an-array/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n\log n)$. The recurrence relation of merge sort is $T(n)=2T(\frac{n}{2})+O(n)$. According to master theorem, the total time complexity is $O(n\log n)$.
+- Space Complexity: $O(n)$. We use an extra array `tmp`, so the total space complexity is $O(n)$.

0912.sort-an-array/SortAnArray.java

@@ -0,0 +1,36 @@
+class SortAnArray {
+    int[] tmp;
+
+    public int[] sortArray(int[] nums) {
+        tmp = new int[nums.length];
+        mergeSort(nums, 0, nums.length - 1);
+        return nums;
+    }
+
+    private void mergeSort(int[] nums, int l, int r) {
+        if (l >= r) {
+            return;
+        }
+        int mid = l + (r - l) / 2;
+        mergeSort(nums, l, mid);
+        mergeSort(nums, mid + 1, r);
+        int i = l, j = mid + 1;
+        int cnt = 0;
+        while (i <= mid && j <= r) {
+            if (nums[i] <= nums[j]) {
+                tmp[cnt++] = nums[i++];
+            } else {
+                tmp[cnt++] = nums[j++];
+            }
+        }
+        while (i <= mid) {
+            tmp[cnt++] = nums[i++];
+        }
+        while (j <= r) {
+            tmp[cnt++] = nums[j++];
+        }
+        for (int k = 0; k < r - l + 1; k++) {
+            nums[k + l] = tmp[k];
+        }
+    }
+}

0916.word-subsets/README.md

@@ -0,0 +1,2 @@
+# [916. Word Subsets](https://leetcode.com/problems/word-subsets/)
+

0916.word-subsets/WordSubsets.java

@@ -0,0 +1,29 @@
+import java.util.LinkedList;
+import java.util.List;
+
+class WordSubsets {
+    private int[] count(String s) {
+        int[] ans = new int[26];
+        for (char c : s.toCharArray()) ans[c - 'a']++;
+        return ans;
+    }
+
+    public List<String> wordSubsets(String[] words1, String[] words2) {
+        int[] word2Max = count("");
+        for (String word2 : words2) {
+            int[] word2Count = count(word2);
+            for (int i = 0; i < 26; i++) word2Max[i] = Math.max(word2Max[i], word2Count[i]);
+        }
+
+        List<String> ans = new LinkedList<>();
+        search: for (String word1 : words1) {
+            int[] word1Count = count(word1);
+            for (int i = 0; i < 26; i++) {
+                if (word1Count[i] < word2Max[i]) continue search;
+            }
+            ans.add(word1);
+        }
+
+        return ans;
+    }
+}

0926.flip-string-to-monotone-increasing/FlipStringToMonotoneIncreasing.java

@@ -0,0 +1,17 @@
+class FlipStringToMonotoneIncreasing {
+    public int minFlipsMonoIncr(String s) {
+        int n = s.length();
+        int dp0 = 0, dp1 = 0;
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            int dp0New = dp0, dp1New = Math.min(dp0, dp1);
+            if (c == '1')
+                dp0New++;
+            else
+                dp1New++;
+            dp0 = dp0New;
+            dp1 = dp1New;
+        }
+        return Math.min(dp0, dp1);
+    }
+}

0926.flip-string-to-monotone-increasing/README.md

@@ -0,0 +1,8 @@
+# [926. Flip String to Monotone Increasing](https://leetcode.com/problems/flip-string-to-monotone-increasing/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of s.
+- Space Complexity: $O(1)$. Only use constant variables here, so the total space complexity is $O(1)$.

0931.minimum-falling-path-sum/MinimumFallingPathSum.java

@@ -0,0 +1,19 @@
+class MinimumFallingPathSum {
+    public int minFallingPathSum(int[][] matrix) {
+        int n = matrix.length;
+        for (int r = n - 2; r >= 0; r--) {
+            for (int c = 0; c < n; c++) {
+                int min = matrix[r + 1][c];
+                if (c > 0)
+                    min = Math.min(min, matrix[r + 1][c - 1]);
+                if (c + 1 < n)
+                    min = Math.min(min, matrix[r + 1][c + 1]);
+                matrix[r][c] += min;
+            }
+        }
+        int res = Integer.MAX_VALUE;
+        for (int num : matrix[0])
+            res = Math.min(res, num);
+        return res;
+    }
+}

0931.minimum-falling-path-sum/README.md

@@ -0,0 +1,2 @@
+# [931. Minimum Falling Path Sum](https://leetcode.com/problems/minimum-falling-path-sum/)
+

0936.stamping-the-sequence/README.md

@@ -0,0 +1,2 @@
+# [936. Stamping The Sequence](https://leetcode.com/problems/stamping-the-sequence/)
+

0936.stamping-the-sequence/StampingTheSequence.java

@@ -0,0 +1,55 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class StampingTheSequence {
+    private boolean canReplace(char[] tChars, int pos, char[] sChars) {
+        for (int i = 0; i < sChars.length; i++) {
+            if (tChars[i + pos] != '?' && tChars[i + pos] != sChars[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private int replace(char[] tChars, int pos, int len, int count) {
+        for (int i = 0; i < len; i++) {
+            if (tChars[i + pos] != '?') {
+                tChars[i + pos] = '?';
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public int[] movesToStamp(String stamp, String target) {
+        char[] sChars = stamp.toCharArray();
+        char[] tChars = target.toCharArray();
+        int count = 0;
+        boolean[] visited = new boolean[tChars.length];
+        List<Integer> res = new ArrayList<>();
+
+        while (count != tChars.length) {
+            boolean didChange = false;
+            for (int i = 0; i <= tChars.length - sChars.length; i++) {
+                if (!visited[i] && canReplace(tChars, i, sChars)) {
+                    count = replace(tChars, i, sChars.length, count);
+                    visited[i] = true;
+                    didChange = true;
+                    res.add(i);
+
+                    if (count == tChars.length) break;
+                }
+            }
+
+            if (!didChange) return new int[0];
+        }
+
+        int[] result = new int[res.size()];
+        int k = 0;
+        for (int i = res.size() - 1; i >= 0; i--) {
+            result[k++] = res.get(i);
+        }
+
+        return result;
+    }
+}

0938.range-sum-of-bst/README.md

@@ -0,0 +1 @@
+# [938. Range Sum of BST](https://leetcode.com/problems/range-sum-of-bst/)

0938.range-sum-of-bst/RangeSumOfBst.java

@@ -0,0 +1,25 @@
+/**
+ * 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 RangeSumOfBst {
+    public int rangeSumBST(TreeNode root, int low, int high) {
+        if (root == null) return 0;
+        if (root.val > high)
+            return rangeSumBST(root.left, low, high);
+        if (root.val < low)
+            return rangeSumBST(root.right, low, high);
+        return root.val + rangeSumBST(root.left, low, high) + rangeSumBST(root.right, low, high);
+    }
+}