add new problems

Author: v-lili

Algorithms Basics/Chapter 1. Array_String/28. Implement strStr().cs

@@ -10,7 +10,7 @@ public int StrStr(string haystack, string needle) {
         int m = haystack.Length, n = needle.Length;
         if (n == 0) return 0;
         if (m < n) return -1;
-        for (int i = 0; i < m - n; i++) {
+        for (int i = 0; i < m - n + 1; i++) {
             int j = 0;
             for (j = 0; j < n; j++) {
                 if (haystack[i + j] != needle[j])

CodeClearWar/151. Reverse Words in a String.cs

@@ -7,18 +7,18 @@ public class Solution {
     public string ReverseWords(string s) {
         if (s == null || s.Length == 0) return "";
         int j = s.Length;
-        var str = new StringBuilder();
+        var reversed = new StringBuilder();
         for (int i = s.Length - 1; i >= 0; i--) {
             if (s[i] == ' ') {
                 j = i;
             } else if (i == 0 || s[i - 1] == ' ') {
-                if (str.Length != 0) {
-                    str.Append(' ');
+                if (reversed.Length != 0) {
+                    reversed.Append(' ');
                 }
-                str.Append(s.Substring(i, j - i));
+                reversed.Append(s.Substring(i, j - i));
             }
         }
-        return str.ToString();
+        return reversed.ToString();
     }
 }
 

CodeClearWar/159. Longest Substring with At Most Two Distinct Characters.cs

@@ -0,0 +1,69 @@
+/*
+The trick is to maintain a sliding window that always satisfies the invariant where there
+are always at most two distinct characters in it. When we add a new character that breaks
+this invariant, how can we move the begin pointer to satisfy the invariant?
+
+we can use a dictionary to save times for each char, and use a counter to save the num of distinct.
+
+when moving the right pointer, we increase the appear times, also increase the counts of distinct char
+ when meet new char;
+when moving the left pointer, we decrease the appear times, and decrease the counts if the appear times = 0;
+
+O(n) run time, O(n) space.
+ */
+
+public class Solution {
+    public int LengthOfLongestSubstringTwoDistinct(string s) {
+        int maxLen = 0;
+        if (s == null || s.Length == 0) return maxLen;
+        var dict = new Dictionary<char, int>();
+        int i = 0, numDistinct = 0;
+        for (int j = 0; j < s.Length; j++) {
+            if (!dict.ContainsKey(s[j]) || dict[s[j]] == 0) {
+                dict[s[j]] = 1;
+                numDistinct++;
+            } else {
+                dict[s[j]] += 1;
+            }
+            while (numDistinct > 2) {
+                dict[s[i]] -= 1;
+                if (dict[s[i]] == 0) numDistinct--;
+                i++;
+            }
+            maxLen = Math.Max(maxLen, j - i + 1);
+        }
+        return maxLen;
+    }
+}
+
+/*
+Similar Questions 
+Longest Substring Without Repeating Characters
+Sliding Window Maximum
+Longest Substring with At Most K Distinct Characters
+
+ */
+
+/*
+if string only contains ascii, then we can use int[256] to save as O(1) space.
+ */
+
+public class Solution {
+    public int LengthOfLongestSubstringTwoDistinct(string s) {
+        int maxLen = 0;
+        if (s == null || s.Length == 0) return maxLen;
+        var dict = new int[256];
+        int i = 0, numDistinct = 0;
+        for (int j = 0; j < s.Length; j++) {
+            if (dict[s[j]] == 0) numDistinct++;
+            dict[s[j]]++;
+            while (numDistinct > 2) {
+                dict[s[i]]--;
+                if (dict[s[i]] == 0) numDistinct--;
+                i++;
+            }
+            maxLen = Math.Max(maxLen, j - i + 1);
+        }
+        return maxLen;
+    }
+}

CodeClearWar/3. Longest Substring Without Repeating Characters.cs

@@ -0,0 +1,92 @@
+/*
+Solution tip: 
+    use two start pointer (slower) l = 0, (faster) r = 0.
+    use a dictionary to save (char,index). use ans to save maxLen.
+    if s[r] is not found in the dictionary, then ans = Math.Max(ans, r - l + 1);
+    if s[r] is found in dictonary, then then l should shift to the new index, 
+    if dict[s[r]] > l, shift to dict[s[r]] + 1; then ans = Math.Max(ans, r - l + 1);
+
+O(n) runtime, O(n) space – Single iteration:
+ */
+
+public class Solution {
+    public int LengthOfLongestSubstring(string s) {
+        if (s == null || s.Length == 0) return 0;
+        int ans = 0;
+        int l = 0;
+        var dict = new Dictionary<char, int>();
+        for (int r = 0; r < s.Length; r++) {
+            var cur = s[r];
+            if (dict.ContainsKey(cur)) {
+                l = Math.Max(l, dict[cur] + 1);
+            }
+            dict[cur] = r;
+            ans = Math.Max(ans, r - l + 1);
+        }
+        return ans;
+    }
+}
+/*
+Next challenges: Longest Substring with At Most Two Distinct Characters
+ */
+
+/*
+if string only contains ascii. then we can use O(1) space. 
+use a int[] charmap = new int[256], instead of dictionary.
+ */
+public class Solution {
+    public int LengthOfLongestSubstring(string s) {
+        int[] charMap = new int[256];
+        Arrays.fill(charMap, -1);
+        int i = 0, maxLen = 0;
+        for (int j = 0; j < s.Length; j++) {
+            if (charMap[s[j]] >= i) {
+                i = charMap[s[j]] + 1;
+            }
+            charMap[s[j]] = j;
+            maxLen = Math.Max(j - i + 1, maxLen);
+        }
+        return maxLen;
+    }
+}
+/*
+By using HashSet as a sliding window, checking if a character in the current can be done in O(1).
+
+A sliding window is an abstract concept commonly used in array/string problems. A window is a 
+range of elements in the array/string which usually defined by the start and end indices, 
+i.e. [i, j)(left-closed, right-open). A sliding window is a window "slides" its two 
+boundaries to the certain direction. For example, if we slide [i, j) to the right by 1 element, 
+then it becomes [i+1, j+1) (left-closed, right-open).
+
+Back to our problem. We use HashSet to store the characters in current window [i, j) (j = i initially). 
+Then we slide the index j to the right. If it is not in the HashSet, we slide j further. Doing so 
+until s[j] is already in the HashSet. At this point, we found the maximum size of substrings 
+without duplicate characters start with index ii. If we do this for all i, we get our answer.
+
+Complexity Analysis
+
+Time complexity : O(2n) = O(n). In the worst case each character will be visited twice by i and j.
+
+Space complexity : O(min(m, n)). Same as the previous approach. We need O(k) space for the 
+sliding window, where k is the size of the Set. The size of the Set is upper bounded by the 
+size of the string n and the size of the charset/alphabet m.
+ */
+
+public class Solution {
+    public int LengthOfLongestSubstring(string s) {
+        int n = s.Length;
+        var set = new HashSet<>();
+        int ans = 0, i = 0, j = 0;
+        while (i < n && j < n) {
+            // try to extend the range [i, j]
+            if (!set.Contains(s.[j])){
+                set.Add(s[j++]));
+                ans = Math.Max(ans, j - i);
+            }
+            else {
+                set.Remove(s[i++]);
+            }
+        }
+        return ans;
+    }
+}

CodeClearWar/65. Valid Number.cs

@@ -0,0 +1,62 @@
+
+/* 
+Solution:
+This problem is very similar to Question [8. String to Integer (atoi)]. Due to many corner
+cases, it is helpful to break the problem down to several components that can be solved
+individually.
+A string could be divided into these four substrings in the order from left to right:
+s1. Leading whitespaces (optional).
+s2. Plus (+) or minus (–) sign (optional).
+s3. Number.
+s4. Optional trailing whitespaces (optional).
+
+On the other hand, a decimal number could be further divided into three parts:
+a. Integer part
+b. Decimal point
+c. Fractional part
+
+A number could contain an optional exponent part, which is marked by a character ‘e’
+followed by a whole number (exponent). For example, “1e10” is numeric. Modify the
+above code to adapt to this new requirement.
+
+ */
+public class Solution {
+    public bool IsNumber(string s) {
+        int i = 0, n = s.Length;
+        while (i < n && s[i] == ' ') i++;
+        if (i < n && (s[i] == '+' || s[i] == '-')) i++;
+        bool isNumeric = false;
+        while (i < n && (s[i] >= '0' && s[i] <= '9')) {
+            i++;
+            isNumeric = true;
+        }
+        // decimal part
+        if (i < n && s[i] == '.') {
+            i++;
+            while (i < n && (s[i] >= '0' && s[i] <= '9')) {
+                i ++;
+                isNumeric = true;
+            }
+        }
+        // exponent part
+        if (isNumeric && i < n && s[i] == 'e') {
+            i++;
+            isNumeric = false;
+            if (i < n && (s[i] == '+' || s[i] == '-')) i++;
+            while (i < n && (s[i] >= '0' && s[i] <= '9')) {
+                i ++;
+                isNumeric = true;
+            }
+        }
+        while (i < n && s[i] == ' ') i++;
+        return isNumeric && i == n;
+    }
+}
+
+/*
+Next challenges: 
+Edit Distance
+Judge Route Circle
+Maximum Swap
+
+ */

CodeClearWar/8. String to Integer (atoi).cs

@@ -13,7 +13,8 @@ public int MyAtoi(string str)
     {
         if (str == null) return 0;
         int i = 0, n = str.Length;
-        while (i < n && char.IsWhiteSpace(str[i])) i++;
+        // while (i < n && char.IsWhiteSpace(str[i])) i++;
+        while (i < n && str[i] == ' ') i++;
         if (i == n) return 0;
         int sign = 1;
         if (i < n && str[i] == '+') {
@@ -23,7 +24,7 @@ public int MyAtoi(string str)
             i++;
         }
         int num = 0;
-        while (i < n && char.IsDigit(str[i])) {
+        while (i < n && char.IsDigit(str[i])) { // can use str[i] >= '0' and str[i] <= '9' to check IsDigit
             int digit = str[i] - '0';
             if (num > maxDiv10 || num == maxDiv10 && digit >= 8) {
                 return sign == 1 ? int.MaxValue : int.MinValue;