feat: update solutions to lc problem: No.0001

No.0001.Two Sum

Author: yanglbme

solution/0000-0099/0001.Two Sum/README.md

@@ -57,9 +57,9 @@
 
 **方法一：哈希表**
 
-用哈希表（字典）存放数组值以及对应的下标。
+我们可以用哈希表（字典） $d$ 存放数组值以及对应的下标。
 
-遍历数组，当发现 `target - nums[i]` 在哈希表中，说明找到了目标值。
+遍历数组 `nums`，当发现 `target - nums[i]` 在哈希表中，说明找到了目标值，返回 `target - nums[i]` 的下标和 `i` 即可。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 `nums` 的长度。
 
@@ -73,11 +73,11 @@
 class Solution:
     def twoSum(self, nums: List[int], target: int) -> List[int]:
         m = {}
-        for i, v in enumerate(nums):
-            x = target - v
-            if x in m:
-                return [m[x], i]
-            m[v] = i
+        for i, x in enumerate(nums):
+            y = target - x
+            if y in m:
+                return [m[y], i]
+            m[x] = i
 ```
 
 ### **Java**
@@ -88,15 +88,14 @@ class Solution:
 class Solution {
     public int[] twoSum(int[] nums, int target) {
         Map<Integer, Integer> m = new HashMap<>();
-        for (int i = 0; i < nums.length; ++i) {
-            int v = nums[i];
-            int x = target - v;
-            if (m.containsKey(x)) {
-                return new int[] {m.get(x), i};
+        for (int i = 0; ; ++i) {
+            int x = nums[i];
+            int y = target - x;
+            if (m.containsKey(y)) {
+                return new int[] {m.get(y), i};
             }
-            m.put(v, i);
+            m.put(x, i);
         }
-        return null;
     }
 }
 ```
@@ -108,13 +107,14 @@ class Solution {
 public:
     vector<int> twoSum(vector<int>& nums, int target) {
         unordered_map<int, int> m;
-        for (int i = 0; i < nums.size(); ++i) {
-            int v = nums[i];
-            int x = target - v;
-            if (m.count(x)) return {m[x], i};
-            m[v] = i;
+        for (int i = 0; ; ++i) {
+            int x = nums[i];
+            int y = target - x;
+            if (m.count(y)) {
+                return {m[y], i};
+            }
+            m[x] = i;
         }
-        return {};
     }
 };
 ```
@@ -124,14 +124,14 @@ public:
 ```go
 func twoSum(nums []int, target int) []int {
 	m := map[int]int{}
-	for i, v := range nums {
-		x := target - v
-		if j, ok := m[x]; ok {
+	for i := 0; ; i++ {
+		x := nums[i]
+		y := target - x
+		if j, ok := m[y]; ok {
 			return []int{j, i}
 		}
-		m[v] = i
+		m[x] = i
 	}
-	return nil
 }
 ```
 
@@ -145,15 +145,14 @@ func twoSum(nums []int, target int) []int {
  */
 var twoSum = function (nums, target) {
     const m = new Map();
-    for (let i = 0; i < nums.length; ++i) {
-        const v = nums[i];
-        const x = target - v;
-        if (m.has(x)) {
-            return [m.get(x), i];
+    for (let i = 0; ; ++i) {
+        const x = nums[i];
+        const y = target - x;
+        if (m.has(y)) {
+            return [m.get(y), i];
         }
-        m.set(v, i);
+        m.set(x, i);
     }
-    return [];
 };
 ```
 
@@ -163,22 +162,16 @@ var twoSum = function (nums, target) {
 public class Solution {
     public int[] TwoSum(int[] nums, int target) {
         var m = new Dictionary<int, int>();
-        for (var i = 0; i < nums.Length; ++i)
-        {
-            int j;
-            int v = nums[i];
-            int x = target - v;
-            if (m.TryGetValue(x, out j))
-            {
+        for (int i = 0, j; ; ++i) {
+            int x = nums[i];
+            int y = target - x;
+            if (m.TryGetValue(y, out j)) {
                 return new [] {j, i};
             }
-            if (!m.ContainsKey(v))
-            {
-                m.Add(v, i);
+            if (!m.ContainsKey(x)) {
+                m.Add(x, i);
             }
-
         }
-        return null;
     }
 }
 ```
@@ -188,42 +181,21 @@ public class Solution {
 ```swift
 class Solution {
     func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
-        var map = [Int: Int]()
+        var m = [Int: Int]()
         var i = 0
-        for num in nums {
-            map[num] = i
-            i = i + 1
-        }
-        i = 0
-        for num in nums {
-            if let otherIndex = map[target - num], otherIndex != i {
-                return [i, otherIndex]
+        while true {
+            let x = nums[i]
+            let y = target - nums[i]
+            if let j = m[target - nums[i]] {
+                return [j, i]
             }
-            i = i + 1
+            m[nums[i]] = i
+            i += 1
         }
-        return []
     }
 }
 ```
 
-### **Nim**
-
-```nim
-import std/enumerate
-
-proc twoSum(nums: seq[int], target: int): seq[int] =
-    var
-        bal: int
-        tdx: int
-    for idx, val in enumerate(nums):
-        bal = target - val
-        if bal in nums:
-            tdx = nums.find(bal)
-            if idx != tdx:
-                return @[idx, tdx]
-
-```
-
 ### **Rust**
 
 ```rust
@@ -243,6 +215,24 @@ pub fn soluation(nums: Vec<i32>, target: i32) -> Vec<i32> {
 }
 ```
 
+### **Nim**
+
+```nim
+import std/enumerate
+
+proc twoSum(nums: seq[int], target: int): seq[int] =
+    var
+        bal: int
+        tdx: int
+    for idx, val in enumerate(nums):
+        bal = target - val
+        if bal in nums:
+            tdx = nums.find(bal)
+            if idx != tdx:
+                return @[idx, tdx]
+
+```
+
 ### **...**
 
 ```