Merge branch 'neetcode-gh:main' into ginger

Author: giggling-ginger

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;
+    }
+};

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();
+    }
+}

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;
+        }
+    }
+}

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;
+    }
+}

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;
+    }
+}

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]);
+  }
+}

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;
+    }
+}

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);
+    }
+}

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;
+    }
+}