Lunski's Clutter

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

1
2
3

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Output: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

1
2

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

1
2
3
4
5
6

Input: nums = [3,3], target = 6
Output: [0,1]
``` 

Constraints:

2 <= nums.length <= 103
-109 <= nums[i] <= 109
-109 <= target <= 109
Only one valid answer exists.

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

<!-- more -->


經典第一題，思路是先把需要的值減去尋訪到的值，如果剩下的值有沒有在Array裡就回傳index。

1. 列index  
for i, num in enumerate(nums):

2. 由數字找index  
keys[remain]

3. 列表對應  
keys[num] = i   


# Java

Time: O(n), Space: O(n)

import java.util.*;
class Solution {
public static int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map=new HashMap<>();

    // There must have two number sum to target, {value: index}
    int[] result=new int[2]; 

    for(int i=0;i<nums.length;i++){
        if(map.containsKey(target-nums[i])){
            result[1]=i;
            result[0]=map.get(target-nums[i]);
            break;
        }
        map.put(nums[i],i);
    }
    return result;
}
public static void main(String[] args) {
    int [] nums = {2,7,11,15};
    System.out.println(Arrays.toString(twoSum(nums,9)));
}

}

1
2

# Python

Time: O(n), Space: O(1)

class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
keys = {}
for i, num in enumerate(nums):
remain = target - num
if remain in keys:
return [keys[remain], i]
else:
keys[num] = i

```

3Sum

Paragraphs let readers get to the point faster.

Audience let us check what are audience really needs.

Namedtuple生成可以使用名字來訪問元素內容的tuple子類，比class更省記憶體。

溫柔的彗星，在不理解歌詞前只覺得是首輕快溫暖的歌，
理解意境發現實際異常沈重…。

開始學日文後，英文就瞬間親切許多，那應該能稱為第二母語吧。