leetcode-题号1

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个
整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

来源：力扣（LeetCode）

看到这道题，以我浅薄的知识储备，我立即想到用findIndex去解决问题。于是有了下面的解题方法。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    let arr = []
    let tem
    for(let i = 0; i < nums.length; i++) {
        tem = arr.findIndex(j => {
            return j === (target - nums[i])
        })
        if (tem !== -1) {
            return [tem, i]
        } else {
            arr.push(nums[i])
        }
    }
};

看了别人的题解后，可以使用map替换findIndex的内部for循环，从而可提高效率，于是有了下面的题解。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    const map = new Map()
    for(let i=0;i<nums.length;i++){
        if(map.has(target-nums[i])){
            return [map.get(target-nums[i]),i]
        }else{
            map.set(nums[i],i)
        }
    }A
    return []
};

【2021-12-22-11:28】我突发奇想，这个map跟对象很像，能不能用对象替换map来解决这个问题。于是

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    let obj = {}
    let tem
    for (let i = 0; i < nums.length; i++) {
        tem =  target - nums[i]
        if (!obj.hasOwnProperty(target - nums[i])) {
            obj[nums[i]] = i
        } else {
            return [obj[tem], i]
        }
    }
};

果然是可以的！