1
2
3

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

1
2

输入：nums = [3,2,4], target = 6
输出：[1,2]

1
2

输入：nums = [3,3], target = 6
输出：[0,1]

1
2
3
4

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

struct Solution;

// @lc code=start
impl Solution {
    /// ## 解题思路
    /// - hashmap
    /// 1. 遍历序列；
    /// 2. 遍历过程中，使用hashmap记录遍历过的序列;
    /// 3. 如果遇到和遍历过的序列和为target的元素，则找到，返回true;
    /// 4. 否则不存在, 返回false；
    pub fn two_sum(nums: Vec<i32>, target: i32) -> Vec<i32> {
        use std::collections::HashMap;
        let mut map: HashMap<i32, i32> = HashMap::new();
        for (i, n) in nums.iter().enumerate() {
            match map.get(n) {
                Some(&pre_idx) => {
                    return vec![pre_idx, i as i32];
                }
                None => {
                    map.insert(target - n, i as i32);
                }
            }
        }
        vec![]
    }
}
// @lc code=end
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test() {
        assert_eq!(Solution::two_sum([2, 7, 11, 15].into(), 9), [0, 1]);
        assert_eq!(Solution::two_sum([3, 2, 4].into(), 6), [1, 2]);
        assert_eq!(Solution::two_sum([3, 3].into(), 6), [0, 1]);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Solution:
    '''
    ## 解题思路
    1. 按序遍历列表；
    2. 使用一个map记录{n:i}；
    3. 遍历当前元素n时，检查map中是否已存在target-n；
       3.1 如果存在，则返回[j, i];
       3.2 否则继续遍历；
    4. 遍历完成后，还没有找到，则返回[];
    '''
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        needed = {}
        for i, n in enumerate(nums):
            if needed.get(target-n) is not None:
                j = needed[target-n]
                return [j, i]
            needed[n] = i
        return []