Merge branch 'neetcode-gh:main' into ginger

Author: giggling-ginger

Diff for: README.md

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    string removeStars(string s) {
+        stack<char> stk;
+        for(int i=0;i<s.size();i++){
+            if(s[i]=='*'){
+                stk.pop();
+            }else stk.push(s[i]);
+        }
+        string res = "";
+        while(!stk.empty()){
+            res += stk.top();
+            stk.pop();
+        }
+         reverse(res.begin(), res.end());
+         return res;
+    }
+};

Diff for: cpp/2390-removing-stars-from-a-string.cpp

@@ -0,0 +1,18 @@
+public class Solution
+{
+    public IList<string> FindRepeatedDnaSequences(string s)
+    {
+        var seen = new HashSet<string>();
+        var result = new HashSet<string>();
+
+        for (var i = 0; i < s.Length - 9; i++)
+        {
+            var cur = s.Substring(i, 10);
+            if (seen.Contains(cur))
+                result.Add(cur);
+            seen.Add(cur);
+        }
+
+        return result.ToList();
+    }
+}

Diff for: csharp/0187-repeated-dna-sequences.cs

@@ -0,0 +1,13 @@
+public class Solution
+{
+    public void ReverseString(char[] s)
+    {
+        var h = s.Length / 2;
+        for (int i = 0; i < h; i++)
+        {
+            var temp = s[i];
+            s[i] = s[s.Length - i - 1];
+            s[s.Length - i - 1] = temp;
+        }
+    }
+}

Diff for: csharp/0344-reverse-string.cs

@@ -0,0 +1,19 @@
+public class Solution
+{
+    public bool CheckSubarraySum(int[] nums, int k)
+    {
+        var remainder = new Dictionary<int, int>();
+        remainder.Add(0, -1);
+        var total = 0;
+        for (var i = 0; i < nums.Length; i++)
+        {
+            total += nums[i];
+            var r = total % k;
+            if (!remainder.ContainsKey(r))
+                remainder.Add(r, i);
+            else if (i - remainder[r] > 1)
+                return true;
+        }
+        return false;
+    }
+}

Diff for: csharp/0523-continuous-subarray-sum.cs

@@ -0,0 +1,18 @@
+public class Solution
+{
+    public string MergeAlternately(string word1, string word2)
+    {
+        var result = string.Empty;
+        var firstPointer = 0;
+        var secondPointer = 0;
+        while (firstPointer < word1.Length || secondPointer < word2.Length)
+        {
+            if (firstPointer < word1.Length)
+                result += word1[firstPointer++];
+
+            if (secondPointer < word2.Length)
+                result += word2[secondPointer++];
+        }
+        return result;
+    }
+}

Diff for: csharp/1768-merge-strings-alternately.cs

@@ -0,0 +1,9 @@
+class Solution {
+  int minCostClimbingStairs(List<int> cost) {
+    for (int i = cost.length - 3; i >= 0; i--) {
+      cost[i] += min(cost[i + 1], cost[i + 2]);
+    }
+
+    return min(cost[0], cost[1]);
+  }
+}

Diff for: dart/0746-min-cost-climbing-stairs.dart

@@ -0,0 +1,11 @@
+class Solution {
+    public int removeDuplicates(int[] nums) {
+        int k = 0;
+        for (int num: nums) {
+            if (k < 2 || nums[k-2] != num) {
+                nums[k++] = num;
+            }
+        }
+        return k;
+    }
+}

Diff for: java/0080-remove-duplicates-from-sorted-array-ii.java

@@ -25,3 +25,32 @@ public static boolean isBalanced(TreeNode root) {
         return dfs(root).getKey();
     }
 }
+
+// Solution using the bottom up approach
+// TC and SC is On
+
+class Solution {
+
+    public int height(TreeNode root){
+        if(root == null){
+            return 0;
+        }
+
+        int lh = height(root.left);
+        int rh = height(root.right);
+
+        return 1 + Math.max(lh,rh);
+    }
+
+    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);
+    }
+}

Diff for: java/0110-balanced-binary-tree.java

@@ -0,0 +1,23 @@
+class Solution {
+    public Node connect(Node root) {
+        Node current = root;
+        Node next = root == null ? null : root.left;
+
+        while (current != null && next != null) {
+            current.left.next = current.right;
+
+            if (current.next != null) {
+                current.right.next = current.next.left;
+            }
+
+            current = current.next;
+
+            if (current == null) {
+                current = next;
+                next = current.left;
+            }
+        }
+
+        return root;
+    }
+}

Diff for: java/0116-populating-next-right-pointers-in-each-node.java

@@ -0,0 +1,27 @@
+class Solution {
+    public ListNode insertionSortList(ListNode head) {
+        ListNode dummy = new ListNode(0, head);
+
+        ListNode prev = head;
+        ListNode cur = head.next;
+        while (cur != null) {
+            if (prev.val <= cur.val) {
+                prev = cur;
+                cur = cur.next;
+            } else {
+                ListNode elem = dummy;
+                while (elem.next.val < cur.val) {
+                    elem = elem.next;
+                }
+
+                prev.next = cur.next;
+                cur.next = elem.next;
+                elem.next = cur;
+
+                cur = prev.next;
+            }
+        }
+
+        return dummy.next;
+    }
+}

Diff for: java/0147-insertion-sort-list.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int findPeakElement(int[] nums) {
+        int l = 0, r = nums.length-1;
+        while(l<=r){
+            int m = l + (r-l)/2;
+            int left = (m-1==-1)?Integer.MIN_VALUE:nums[m-1];
+            int right = (m+1==nums.length)?Integer.MIN_VALUE:nums[m+1];
+            if(nums[m]>left && nums[m]>right) return m;
+            else if(nums[m]<left) r=m-1;
+            else l = m+1;
+        }
+        return 0;
+    }
+}

Diff for: java/0162-find-peak-element.java

@@ -4,7 +4,6 @@ public TreeNode invertTree(TreeNode root) {
         if (root == null) return null;
         TreeNode node = new TreeNode(root.val);
         node.right = invertTree(root.left);
-        node.val = root.val;
         node.left = invertTree(root.right);
         return node;
     }

Diff for: java/0226-invert-binary-tree.java

@@ -0,0 +1,25 @@
+class NumMatrix {
+    int[][] preSum;
+
+    public NumMatrix(int[][] matrix) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+        preSum = new int[m + 1][n + 1];
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                preSum[i + 1][j + 1] = preSum[i + 1][j] + preSum[i][j + 1] - preSum[i][j] + matrix[i][j]; 
+            }
+        }
+    }
+    
+    public int sumRegion(int row1, int col1, int row2, int col2) {
+        return preSum[row2 + 1][col2 + 1] - preSum[row2 + 1][col1] - preSum[row1][col2 + 1] + preSum[row1][col1];
+    }
+}
+
+/**
+ * Your NumMatrix object will be instantiated and called as such:
+ * NumMatrix obj = new NumMatrix(matrix);
+ * int param_1 = obj.sumRegion(row1,col1,row2,col2);
+ */

Diff for: java/0304-range-sum-query-2d-immutable.java

@@ -0,0 +1,21 @@
+public class Solution {
+    public int numberOfArithmeticSlices(int[] nums) {
+        int res = 0;
+        int n = nums.length;
+
+        Map<Long, Integer>[] dp = new HashMap[n];
+        for (int i = 0; i < n; i++) {
+            dp[i] = new HashMap<>();
+        }
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < i; j++) {
+                long diff = (long) nums[i] - (long) nums[j];
+                dp[i].put(diff, dp[i].getOrDefault(diff, 0) + 1 + dp[j].getOrDefault(diff, 0));
+                res += dp[j].getOrDefault(diff, 0);
+            }
+        }
+
+        return res;
+    }
+}

Diff for: java/0446-arithmetic-slices-ii-subsequence.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int findContentChildren(int[] g, int[] s) {
+        Arrays.sort(g);
+        Arrays.sort(s);
+
+        int i = 0, j = 0;
+        while(i < g.length){
+            while(j < s.length && g[i] > s[j])
+                j += 1;
+            if(j == s.length)
+                break;
+            i += 1;
+            j += 1;        
+        }
+        return i;
+    }
+}

Diff for: java/0455-assign-cookies.java

@@ -0,0 +1,52 @@
+class Solution {
+    public int[][] imageSmoother(int[][] img) {
+        int ROWS = img.length, COLS = img[0].length;
+        int[][] res = new int[ROWS][COLS];
+
+        for(int r = 0; r < ROWS; r++){
+            for(int c = 0; c < COLS; c++){
+                int total = 0, cnt = 0;
+                for(int i = r - 1; i < r + 2; i++){
+                    for(int j = c - 1; j < c + 2; j++){
+                        if(i < 0 || i == ROWS || j < 0 || j == COLS)
+                            continue;
+                        total += img[i][j];
+                        cnt += 1;    
+                    }
+                }
+                res[r][c] = total / cnt;
+            }
+        }
+        return res;
+    }
+}
+
+//  Optimal  Solution
+
+class Solution {
+    public int[][] imageSmoother(int[][] img) {
+        int ROWS = img.length, COLS = img[0].length;
+
+        for(int r = 0; r < ROWS; r++){
+            for(int c = 0; c < COLS; c++){
+                int total = 0, cnt = 0;
+
+                for(int i = r - 1; i < r + 2; i++){
+                    for(int j = c - 1; j < c + 2; j++){
+                        if(i < 0 || i == ROWS || j < 0 || j == COLS)
+                            continue;
+                        total += img[i][j] % 256;
+                        cnt += 1;    
+                    }
+                }
+                img[r][c] = img[r][c] ^ (total / cnt) << 8;
+            }
+        }
+        for(int r = 0; r < ROWS; r++){
+            for(int c = 0; c < COLS; c++){
+                img[r][c] = img[r][c] >> 8;
+            }
+        }
+        return img;
+    }
+}

Diff for: java/0661-image-smoother.java

@@ -5,7 +5,9 @@ public int search(int[] nums, int target) {
         int j = nums.length - 1;
 
         while (i <= j) {
-            int mid = (i + j) / 2;
+            // mid is calculated this way to prevent integer overflow.
+            // See: https://blog.research.google/2006/06/extra-extra-read-all-about-it-nearly.html
+            int mid = i + (j - i) / 2;
 
             if (nums[mid] == target) return mid; else if (
                 nums[mid] < target

Diff for: java/0704-binary-search.java

@@ -0,0 +1,17 @@
+class Solution {
+    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+        ArrayList<Integer> ls1 = new ArrayList<>();
+        ArrayList<Integer> ls2 = new ArrayList<>();
+        tree(root1, ls1);
+        tree(root2, ls2);
+        return ls1.equals(ls2);
+    }
+    private void tree(TreeNode root, List<Integer> ls){
+        if(root == null)
+            return;
+        if(root.left == null && root.right == null)
+            ls.add(root.val);
+        tree(root.left, ls);
+        tree(root.right, ls);        
+    }
+}