Add Code Clear War for starting

Author: v-lili

Algorithms Basics/Chapter 1. Array_String/1. Two Sum.cs

@@ -7,13 +7,15 @@ public int[] TwoSum(int[] nums, int target) {
         var dict = new Dictionary<int, int>();
         for (int i = 0; i < nums.Length; i++) {
             var cur = nums[i];
-            var complement = target - cur;
-            if (dict.ContainsKey(complement)) {
-                result = new int[] { dict[complement], i };
+            var completement = target - cur;
+            if (dict.ContainsKey(completement)) {
+                result = new int[] { dict[completement], i };
                 break;
             }
-            // If using dict.Add(cur, i) will get exception when value cur already exists in dict.
-            dict[cur] = i;
+            if (!dict.ContainsKey(cur))
+            {
+                dict[cur] = i;
+            }
         }
         return result;
     }

CodeClearWar/1. Two Sum.cs

@@ -0,0 +1,21 @@
+public class Solution {
+    public int[] TwoSum(int[] nums, int target) {
+        int[] result = null;
+        if (nums == null || nums.Length < 2) {
+            return result;
+        }
+        var dict = new Dictionary<int, int>();
+        for (int i = 0; i < nums.Length; i++) {
+            var cur = nums[i];
+            var completement = target - cur;
+            if (dict.ContainsKey(completement)) {
+                result = new int[] { dict[completement], i };
+                break;
+            }
+            if (!dict.ContainsKey(cur)) {
+                dict[cur] = i;
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,26 @@
+/*
+Similar problems:
+1. Two Sum
+653. Two Sum IV - Input is a BST
+ */
+public class Solution {
+    public int[] TwoSum(int[] nums, int target) {
+        int[] result = null;
+        if (nums == null || nums.Length < 2) {
+            return result;
+        }
+        for (int i = 0, j = nums.Length - 1; i < j;) {
+            var sum = nums[i] + nums[j];
+            if (sum == target) {
+                result = new int[] { i + 1, j + 1 };
+                break;
+            }
+            if (sum < target) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return result;
+    }
+}

CodeClearWar/170. Two Sum III - Data structure design.cs

@@ -0,0 +1,36 @@
+public class TwoSum {
+
+    private List<int> list;
+    
+    /** Initialize your data structure here. */
+    public TwoSum() {
+        this.list = new List<int>();
+    }
+    /** Add the number to an internal data structure.. */
+    public void Add(int number) {
+        list.Add(number);
+    }
+    /** Find if there exists any pair of numbers which sum is equal to the value. */
+    public bool Find(int value) {
+        if (list == null || list.Count < 2) {
+            return false;
+        }
+        var set = new HashSet<int>();
+        for (int i = 0; i < list.Count; i++) {
+            var cur = list[i];
+            var completement = value - cur;
+            if (set.Contains(completement)) {
+                return true;
+            }
+            set.Add(cur);
+        }
+        return false;
+    }
+}
+
+/**
+ * Your TwoSum object will be instantiated and called as such:
+ * TwoSum obj = new TwoSum();
+ * obj.Add(number);
+ * bool param_2 = obj.Find(value);
+ */

CodeClearWar/653. Two Sum IV - Input is a BST.cs

@@ -0,0 +1,55 @@
+public class Solution {
+    // 1 BFS and HashSet, iteration
+    public bool FindTarget(TreeNode root, int k) {
+        if (root == null) return false;
+        var set = new HashSet<int>();
+        var q = new Queue<TreeNode>();
+        q.Enqueue(root);
+        while (q.Count > 0) {
+            var node = q.Dequeue();
+            var completment = k - node.val;
+            if (set.Contains(completment)) {
+                return true;
+            }
+            set.Add(node.val);
+            if (node.left != null) q.Enqueue(node.left);
+            if (node.right != null) q.Enqueue(node.right);
+        }
+        return false;
+    }
+
+    // 2 just HashSet, recursive
+    public bool FindTarget(TreeNode root, int k) {
+        var set = new HashSet<int>();
+        return Find(root, k, set);
+    }
+    private bool Find(TreeNode root, int k, HashSet<int> set) {
+        if (root == null) return false;
+        if (set.Contains(k - root.val)) return true;
+        set.Add(root.val);
+        return Find(root.left, k, set) || Find(root.right, k, set);
+    }
+
+    // 3 Transfer BST to ordering list, then use two pointers to do the twoSum
+    public bool FindTarget(TreeNode root, int k) {
+        if (root == null) return false;
+        List<int> list = new List<int>();
+        InOrderTranverse(root, list);
+        for (int i = 0, j = list.Count - 1; i < j;) {
+            var sum = list[i] + list[j];
+            if (sum == k) return true;
+            if (sum < k) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return false;
+    }
+    private void InOrderTranverse(TreeNode root, List<int> list) {
+        if (root == null) return;
+        InOrderTranverse(root.left, list);
+        list.Add(root.val);
+        InOrderTranverse(root.right, list);
+    }
+}

LeetcodeCShaprDotNetCore/Solution.cs

@@ -2,7 +2,10 @@
 using System.Collections.Generic;
 using System.Text;
 
-
-namespace LeetcodeCShaprDotNetCore {
-    
+namespace LeetcodeCShaprDotNetCore
+{
+    public class Solution
+    {
+        
+    }
 }

LeetcodeCShaprDotNetCore/TwoSum.cs

@@ -0,0 +1,8 @@
+namespace LeetcodeCShaprDotNetCore
+{
+    using System.Collections.Generic;
+    public class TwoSum
+    {
+        
+    }
+}