var twoSum = function(nums, target) {
    //暴力
    //外层循环从下标0遍历到倒数第2个数，因为还要考虑里程循环
    var len=nums.length;
    for(var i=0;i<len-1;i++){
        //里层循环则是在每次外层循环下，i+1的后面循环一一匹配
        for(var j=i+1;j<len;j++){
            //采用严格相等
            if(nums[i]+nums[j]===target){
                return [i,j];
            }
        }
    }
    return [];
};

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n=nums.size();
        for(int i=0;i<n-1;++i){
            for(int j=i+1;j<n;++j){
                if(nums[i]+nums[j] == target){
                    return {i,j};
                }
            }
        }
        return {};
    }
};

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int n=nums.length;
        for(int i=0;i<n-1;++i){
            for(int j=i+1;j<n;++j){
                if(nums[i]+nums[j] == target){
                    return new int[]{i,j};
                }
            }
        }
        //表示返回为空数组
        return new int[0];
    }
}

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        n=len(nums)
        for i in range(n-1):
            for j in range(i+1,n):
                if nums[i] + nums[j] == target:
                    return [i,j]
        return []

func twoSum(nums []int, target int) []int {
    for i := range nums {
        for j := i+1; j<len(nums); j++ {
            if nums[i]+nums[j] == target{
                return []int {i,j}
            }
        }
    }
    return nil
}

var twoSum = function(nums, target) {
    //创建哈希表,key值是nums里的数值，value值则是下标
    let map = new Map();
    //目标值 - 遍历nums值 = 需要的另一个整数，而且也可以做到最先出现的数为有效
    for(let i=0;i<nums.length;i++){
        let another = target - nums[i];
        //如果another这个值在nums里，并且get到它的index不重复的话，就返回结果
        if(map.has(another) && map.get(another) != i ){
            return [map.get(another),i];
        }
        //如果发现当前nums[i]不在哈希表中，就加进去
        map.set(nums[i],i);
    }
    //找了所有的情况但是都没结果
    return [];
};

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //使用无序哈希表,key是数值，value是下标
        unordered_map<int,int> map;
        for(int i=0;i<nums.size();++i){
            //查找哈希表是否有应匹配到的另一个值
            auto it = map.find(target-nums[i]);
            //由于我使用的是无序哈希表，所以如果值index重复的话，一定放到最后的位置
            if(it != map.end()){
                return {it->second,i};
            }
            //如果发现nums[index]不再哈希表就加上
            map[nums[i]]=i;
        }
        return {};
    }
};

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<nums.length;++i){
            //判断another是否在哈希表中，再就返回结果
            //不用担心值重复后的下标也跟着重复的事情发生
            if(map.containsKey(target-nums[i])){
                return new int[]{map.get(target-nums[i]),i};
            }
            //如果nums[index]不在哈希表中
            map.put(nums[i],i);
        }
        return new int[0];
    }
}

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

func twoSum(nums []int, target int) []int {
    hashtable := map[int]int{}
    for i,x := range nums {
        if another_index,ok := hashtable[target-x];ok {
            fmt.Println(ok)//返回true
            return []int{another_index,i}
        }
        hashtable[x]=i
    }
    return nil
}