JS实现给定一个整数数组和目标数组,请你在数组中找出和为目标值target的那两个整数,并返回他们的数组下标

好的，可以使用暴力枚举或哈希表两种方法来解决这个问题。以下是两种方法的实现：

1. 暴力枚举

暴力枚举的思路比较简单，遍历每一个数，再遍历它后面的数，看是否存在两个数的和为target，时间复杂度为O(n^2)。

function twoSum(nums, target) {
  for (let i = 0; i < nums.length; i++) {
    for (let j = i + 1; j < nums.length; j++) {
      if (nums[i] + nums[j] === target) {
        return [i, j];
      }
    }
  }
  return [];
}

2. 哈希表

哈希表的思路是先将每个数和它的下标存入哈希表中，再遍历每一个数，查找哈希表中是否存在target-当前数的值，时间复杂度为O(n)。

function twoSum(nums, target) {
  const hash = new Map();
  for (let i = 0; i < nums.length; i++) {
    if (hash.has(target - nums[i])) {
      return [hash.get(target - nums[i]), i];
    }
    hash.set(nums[i], i);
  }
  return [];
}

以上两种方法都可以解决这个问题，但是哈希表的时间复杂度更低，因此更加优秀。

相关问题

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

好的，这是一个经典的算法题，可以用哈希表来实现，时间复杂度为 O(n)。具体实现如下：

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int* result = (int*)malloc(sizeof(int) * 2);
    *returnSize = 2;
    int hash[numsSize];
    memset(hash, -1, sizeof(hash));
    for (int i = 0; i < numsSize; i++) {
        int complement = target - nums[i];
        if (hash[complement] != -1) {
            result[0] = hash[complement];
            result[1] = i;
            return result;
        }
        hash[nums[i]] = i;
    }
    return result;
}

其中，nums 表示整数数组， numsSize 表示数组长度， target 表示目标值， returnSize 表示返回数组的长度。函数返回一个长度为 2 的数组，表示找到的两个数的下标。

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

可以使用哈希表来解决这个问题，遍历数组，对于每个元素，在哈希表中查找是否存在一个与它相加等于目标值的元素，如果存在，则返回它们的下标，否则将当前元素存入哈希表中等待后续查找。

Python代码如下：

def twoSum(nums, target):
    hash_map = {}
    for i, num in enumerate(nums):
        if target - num in hash_map:
            return [hash_map[target - num], i]
        hash_map[num] = i
    return []

其中，`enumerate()`函数可以同时遍历数组中的元素和它们的下标。