Add new code in clear code war

Author: v-lili

Algorithms Basics/Chapter 2. Linked List/125. Valid Palindrome.cs

@@ -1,24 +1,22 @@
 
+/* O(n) runtime, O(1) space */
+
 public class Solution {
     public bool IsPalindrome(string s) {
-        if (s.Length == 0) return true;
         int left = 0, right = s.Length - 1;
-        while (left < right) {
-            while (left < right && !char.IsLetterOrDigit(s[left])){
-                left++;
-            } 
-            if (left == right) break;
-            while (left < right && !char.IsLetterOrDigit(s[right])) {
-                right--;
-            }
-            if (left == right) break;
-            if (char.ToLower(s[left]) != char.ToLower(s[right])) {
-                return false;
-            }
-            left++;
-            right--;
-            
+        while (left < right)
+        {
+            while (left < right && !char.IsLetterOrDigit(s[left])) left++;
+            while (left < right && !char.IsLetterOrDigit(s[right])) right--;
+            if (char.ToLower(s[left]) != char.ToLower(s[right])) return false;
+            left++; right--;
         }
         return true;
     }
-}   
+}
+
+/*
+Similar Questions or Next challenges:
+Palindrome Linked List
+Valid Palindrome II
+ */   

CodeClearWar/1. Two Sum.cs

@@ -12,7 +12,8 @@
 to get the value, index.
 
 That's it! Just do re-mapping, trade off is O(n) space vs O(n) time.
-
+The solution is 
+    O(n) runtime, O(n) space
  */
 public class Solution {
     public int[] TwoSum(int[] nums, int target) {
@@ -23,9 +24,7 @@ public int[] TwoSum(int[] nums, int target) {
             if (dict.ContainsKey(complement)) {
                 return result = new int[] { dict[complement], i };
             }
-            if (!dict.ContainsKey(cur)) {
-                dict[cur] = i;
-            }
+            dict[cur] = i;
         }
         throw new Exception("No two sum solution");
     }

CodeClearWar/125. Valid Palindrome.cs

@@ -0,0 +1,22 @@
+
+/* O(n) runtime, O(1) space */
+
+public class Solution {
+    public bool IsPalindrome(string s) {
+        int left = 0, right = s.Length - 1;
+        while (left < right)
+        {
+            while (left < right && !char.IsLetterOrDigit(s[left])) left++;
+            while (left < right && !char.IsLetterOrDigit(s[right])) right--;
+            if (char.ToLower(s[left]) != char.ToLower(s[right])) return false;
+            left++; right--;
+        }
+        return true;
+    }
+}
+
+/*
+Similar Questions or Next challenges:
+Palindrome Linked List
+Valid Palindrome II
+ */   

CodeClearWar/151. Reverse Words in a String.cs

@@ -0,0 +1,39 @@
+/* O(n) runtime, O(n) space:
+One simple approach is a two-pass solution: First pass to split the string by spaces into an
+array of words, then second pass to extract the words in reversed order.
+We can do better in one-pass. While iterating the string in reverse order, we keep track of
+a word’s begin and end position. When we are at the beginning of a word, we append it. */
+public class Solution {
+    public string ReverseWords(string s) {
+        if (s == null || s.Length == 0) return "";
+        int j = s.Length;
+        var str = 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(' ');
+                }
+                str.Append(s.Substring(i, j - i));
+            }
+        }
+        return str.ToString();
+    }
+}
+
+// use buildin trim and split
+public class Solution {
+    public string ReverseWords(string s) {
+        if (s == null || s.Length == 0 ) return "";
+        string[] array = s.Split(' ');
+        StringBuilder sb = new StringBuilder();
+        for (int i = array.Length - 1; i >= 0; i--) {
+            if (array[i].Trim() != "") {
+                sb.Append(array[i]).Append(" ");
+            }
+        }
+        // remove last " "
+        return sb.ToString().TrimStart().TrimEnd();
+    }
+}

CodeClearWar/167. Two Sum II - Input array is sorted.cs

@@ -20,6 +20,8 @@ public int[] TwoSum(int[] nums, int target) {
     }
 }
 
+
+
 /*
 Next challenges:
 Find the Duplicate Number

CodeClearWar/186. Reverse Words in a String II.cs

@@ -0,0 +1,38 @@
+/*
+O(n) runtime, O(1) space – In-place reverse:
+Let us indicate the i th word by w i and its reversal as w i ′. Notice that when you reverse a
+word twice, you get back the original word. That is, (w i ′)′ = w i .
+The input string is w 1 w 2 … w n . If we reverse the entire string, it becomes w n ′ … w 2 ′ w 1 ′.
+Finally, we reverse each individual word and it becomes w n … w 2 w 1 . Similarly, the same
+result could be reached by reversing each individual word first, and then reverse the
+entire string.
+ */
+
+ public class Solution {
+    public void ReverseWords(char[] str) {
+        if (str == null || str.Length <= 1) return;
+        Reverse(str, 0, str.Length - 1);
+        int l = 0;
+        for (int r = 0; r < str.Length; r++) {
+            if (r + 1 == str.Length || str[r + 1] == ' ') {
+                Reverse(str, l, r);
+                l = r + 2;
+            }
+        }
+    }
+    private void Reverse(char[] str, int left, int right) {
+        while (left < right) {
+            var temp = str[left];
+            str[left] = str[right];
+            str[right] = temp;
+            left++;
+            right--;
+        }
+    }
+}
+
+/*
+Similar Questions 
+Reverse Words in a String
+Rotate Array
+ */

CodeClearWar/189. Rotate Array.cs

@@ -0,0 +1,111 @@
+/*
+Approach #4 Using Reverse [Accepted]
+Algorithm
+
+This approach is based on the fact that when we rotate the array k times, k elements from 
+the back end of the array come to the front and the rest of the elements from the front shift backwards.
+
+In this approach, we firstly reverse all the elements of the array. Then, reversing the 
+first k elements followed by reversing the rest n-k elements gives us the required result.
+
+"double reverse tech"
+Complexity Analysis
+
+Time complexity : O(n). nn elements are reversed a total of three times.
+
+Space complexity : O(1). No extra space is used.
+ */
+public class Solution {
+    public void Rotate(int[] nums, int k) {
+        if (nums == null || nums.Length == 0 || k % nums.Length == 0) return;
+        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) {
+            var temp = nums[start];
+            nums[start] = nums[end];
+            nums[end] = temp;
+            start++;
+            end--;
+        }
+    }
+}
+
+/*
+Approach #1 Brute Force [Time Limit Exceeded]
+The simplest approach is to rotate all the elements of the array in k steps by rotating 
+the elements by 1 unit in each step.
+O(n*k) runtime, O(1) sapce. No extra space is used.
+ */
+public class Solution {
+    public void Rotate(int[] nums, int k) {
+        int temp, previous;
+        for (int i = 0; i < k; i++) {
+            previous = nums[nums.Length - 1];
+            for (int j = 0; j < nums.Length; j++) {
+                temp = nums[j];
+                nums[j] = previous;
+                previous = temp;
+            }
+        }
+    }
+}
+
+/*
+Approach #2 Using Extra Array [Accepted]
+We use an extra array in which we place every element of the array at its 
+correct position i.e. the number at index ii in the original array is placed 
+at the index (i+k). Then, we copy the new array to the original one.
+
+O(n) runtime. One pass is used to put the numbers in the new array. And another pass 
+to copy the new array to the original one.
+
+O(n) space. Another array of the same size is used.
+
+ */
+
+public class Solution {
+    public void Rotate(int[] nums, int k) {
+        int[] a = new int[nums.Length];
+        for (int i = 0; i < nums.Length; i++) {
+            a[(i + k) % nums.Length] = nums[i];
+        }
+        for (int i = 0; i < nums.Length; i++) {
+            nums[i] = a[i];
+        }
+    }
+}
+
+/*
+Approach #3 Using Cyclic Replacements [Accepted]
+Complexity Analysis
+Time complexity : O(n). Only one pass is used.
+Space complexity : O(1). Constant extra space is used.
+ */
+public class Solution {
+    public void Rotate(int[] nums, int k) {
+        k = k % nums.Length;
+        int count = 0;
+        for (int start = 0; count < nums.Length; start++) {
+            int current = start;
+            int prev = nums[start];
+            do {
+                int next = (current + k) % nums.Length;
+                int temp = nums[next];
+                nums[next] = prev;
+                prev = temp;
+                current = next;
+                count++;
+            } while (start != current); // current will finally meet start, the least common multiple of k and n
+        }
+    }
+}
+
+/*
+Similar Questions 
+Rotate List
+Reverse Words in a String II
+ */

CodeClearWar/28. Implement strStr().cs

@@ -0,0 +1,29 @@
+/*
+Similar Problem:
+459. Repeated Substring Pattern
+ */
+public class Solution {
+    public int StrStr(string haystack, string needle) {
+        if (haystack == null || needle == null) {
+            return -1;
+        }
+        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++) {
+            int j = 0;
+            for (j = 0; j < n; j++) {
+                if (haystack[i + j] != needle[j])
+                    break;
+            }
+            if (j == n) return i;
+        }
+        return -1;
+    }
+}
+
+/*
+Next challenges: 
+Shortest Palindrome
+Repeated Substring Pattern
+ */

LeetcodeCShaprDotNetCore/Program.cs

@@ -3,7 +3,9 @@
 namespace LeetcodeCShaprDotNetCore {
     class Program {
         static void Main(string[] args) {
-
+            var s = new int[]{ 1, 0, -1, 0, -2, 2 };
+            var res = Solution.FourSum(s, 0);
+            Console.ReadLine();
         }
 
     }

LeetcodeCShaprDotNetCore/Solution.cs

@@ -4,5 +4,19 @@
 
 namespace LeetcodeCShaprDotNetCore
 {
-
+    public class Solution
+    {
+        public bool IsPalindrome(string s)
+        {
+            int left = 0, right = s.Length - 1;
+            while (left < right)
+            {
+                while (left < right && !char.IsLetterOrDigit(s[left])) left++;
+                while (left < right && !char.IsLetterOrDigit(s[right])) right--;
+                if (char.ToLower(s[left]) != char.ToLower(s[right])) return false;
+                left++; right--;
+            }
+            return true;
+        }
+    }
 }