Question

我在JavaScript会话中。在我的编码练习中找到这段代码。我理解逻辑，但我没有得到这个地图[nums [x]]条件。

function twoSum(nums, target_num) {  
    var map = [];  
    var indexnum = [];  

    for (var x = 0; x < nums.length; x++)  
    {  
        if (map[nums[x]] != null)  
        // what they meant by map[nums[x]]
        {  
            index = map[nums[x]];  
            indexnum[0] = index+1;  
            indexnum[1] = x+1;  
            break;  
        }  
        else  
        {  
            map[target_num - nums[x]] = x;  
        }  
    }  
    return indexnum;  
    }  
console.log(twoSum([10,20,10,40,50,60,70],50));

我试图获取指定数组中的元素对，其总和等于特定目标数。我写了下面的代码。

function arraypair(array,sum){
        for (i = 0;i < array.length;i++) {
            var first = array[i];
            for (j = i + 1;j < array.length;j++) {
                var second = array[j];

                if ((first + second) == sum) {
            alert('First: ' + first + ' Second ' + second + ' SUM ' + sum);
            console.log('First: ' + first + ' Second ' + second);
                }
            }

        }
}

var a = [2, 4, 3, 5, 6, -2, 4, 7, 8, 9];

arraypair(a,7);

是否有比上述两种解决方案更优化的方法？有人可以解释第一个解决方案究竟映射[nums [x]]这个条件指向什么？

Answer 1

您看到的地图值是一个查找表， twoSum 方法实现了所谓的Dynamic Programming

在动态编程中，存储您稍后可以重复使用的计算值以找到解决方案。

让我们研究一下如何更好地理解它：

twoSum([10,20,40,50,60,70], 50)
//I removed one of the duplicate 10s to make the example simpler

在迭代0中：

值是10.我们的目标数是50. 当我在索引0中看到数字10时，我记下如果我在此列表中找到40（50 - 10 = 40），那么我可以在索引0中找到它的对。

所以在我们的地图中，40点到0。

在迭代2中：

值是40.我看地图我的地图看我以前发现了一对40。

map[nums[x]]（与map[40]相同）将返回0.
这意味着我在索引0处有一对40。
0和2成对。

这现在有意义吗？

与您有2个嵌套循环的解决方案不同，您可以存储以前计算的值。这将节省您的处理时间，但会在内存中浪费更多空间（因为查找表将需要内存）

此外，由于您是在javascript中编写的，因此地图可以是对象而不是数组。它还可以使调试变得更容易;）

Answer 2

使用时间复杂度约为O（n）的HashMap方法，下面是以下代码：

let twoSum = (array, sum) => {
    let hashMap = {},
      results = []

        for (let i = 0; i < array.length; i++){
            if (hashMap[array[i]]){
                results.push([hashMap[array[i]], array[i]])
            }else{
                hashMap[sum - array[i]] = array[i];
            }
          }
          return results;
    }
console.log(twoSum([10,20,10,40,50,60,70,30],50));

结果：

{[10, 40],[20, 30]}

我认为代码是自我解释的，即使你需要帮助来理解它，请告诉我。我会很乐意解释它。

希望有所帮助......

Answer 3

请尝试以下代码。它将为您提供所有唯一对，其总和将等于targetSum。它执行二进制搜索，因此性能会更好。该解决方案的时间复杂度为O（NLogN）

((arr,targetSum) => {
    if ((arr && arr.length === 0) || targetSum === undefined) {
        return false;
    } else {
        for (let x = 0; x <=arr.length -1; x++) {
            let partnerInPair = targetSum - arr[x];
            let start = x+1;
            let end = (arr.length) - 2;

             while(start <= end) {
                let mid = parseInt(((start + end)/2));
                if (arr[mid] === partnerInPair) {
                    console.log(`Pairs are ${arr[x]} and ${arr[mid]} `);
                    break;
                } else if(partnerInPair < arr[mid]) {
                    end = mid - 1;
                } else if(partnerInPair > arr[mid]) {
                    start = mid + 1;
                }
             }
        };

    };
})([0,1,2,3,4,5,6,7,8,9], 10)

Answer 4

function twoSum(arr, target) {
    let res = [];
    let indexes = [];
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (target === arr[i] + arr[j] && !indexes.includes(i) && !indexes.includes(j)) {
                res.push([arr[i], arr[j]]);
                indexes.push(i);
                indexes.push(j);
            }
        }
    }
    return res;
}
console.log('Result - ',
    twoSum([1,2,3,4,5,6,6,6,6,6,6,6,6,6,7,8,9,10], 12)
);

蛮力。

Answer 5

function twoSum(arr, S) {
 const sum = [];
  for(let i = 0; i< arr.length; i++) {
    for(let j = i+1;  j < arr.length; j++) {
      if(S == arr[i] + arr[j]) sum.push([arr[i],arr[j]])
    }
  }
 return sum
}

蛮力不是解决问题的最佳方法，但它确实有效。

Answer 6

function twoSum(arr){

  let constant = 17;

  for(let i=0;i<arr.length-2;i++){

      for(let j=i+1;j<arr.length;j++){

          if(arr[i]+arr[j] === constant){

              console.log(arr[i],arr[j]);
          }
      }
   }
}

Answer 7

let myArr = [2, 4, 3, 5, 7, 8, 9];

function getPair(arr, targetNum) {
  for (let i = 0; i < arr.length; i++) {
    let cNum = arr[i]; //my current number
    for (let j = i; j < arr.length; j++) {
      if (cNum !== arr[j] && cNum + arr[j] === targetNum) {
        let pair = {};
        pair.key1 = cNum;
        pair.key2 = arr[j];
        console.log(pair);
      }

    }
  }
}
getPair(myArr, 7)

Answer 8

const findTwoNum = ((arr, value) => {
let result = [];
for(let i= 0; i< arr.length-1; i++) {
    if(arr[i] > value) {
        continue;
    }
    if(arr.includes(value-arr[i])) {
        result.push(arr[i]);
        result.push(value-arr[i]);
        break;;
    }   
}
  return result;
});
let arr = [20,10,40,50,60,70,30];
const value = 120;
console.log(findTwoNum(arr, value));

输出：数组 [50, 70]

Answer 9

  let  sumArray = (arr,target) => {
    let ar = []
    arr.forEach((element,index) => {
      console.log(index);      
      arr.forEach((element2, index2) => {
              if(  (index2 > index) && (element + element2 == target)){
                ar.push({element, element2})             
              }
          });
      });
      return ar
    }
    
      console.log(sumArray([8, 7, 2, 5, 3, 1],10))

Answer 10

使用 {} 哈希对象进行存储和快速查找。
使用简单的 for 循环，这样你就可以在找到合适的组合后立即返回； .forEach() 之类的数组方法无论如何都必须完成迭代。
并确保你处理这样的边缘情况：twoSum([1,2,3,4], 8)---应该返回undefined，但如果你不检查!== i（见下文），你会错误地返回 [4,4]。想想为什么会这样......

function twoSum(nums, target) {
  const lookup = {};
  
  for (let i = 0; i < nums.length; i++) {
    const n = nums[i];
    
    if (lookup[n] === undefined) {//lookup n; seen it before?
      lookup[n] = i; //no, so add to dictionary with index as value
    }
    
    //seen target - n before? if so, is it different than n?
    if (lookup[target - n] !== undefined && lookup[target - n] !== i) {
      return [target - n, n];//yep, so we return our answer!
    }  
  }
  
  return undefined;//didn't find anything, so return undefined
}

Answer 11

简单的解决方案将在javascript中显示：

var arr = [7,5,10,-5,9,14,45,77,5,3];
var arrLen = arr.length;
var sum = 15;

function findSumOfArrayInGiven (arr, arrLen, sum){
  var left = 0;
  var right = arrLen - 1;

  // Sort Array in Ascending Order
  arr = arr.sort(function(a, b) {
    return a - b;
  })

  // Iterate Over
  while(left < right){
    if(arr[left] + arr[right] === sum){
      return {
          res : true,
          matchNum: arr[left] + ' + ' + arr[right]
      };
    }else if(arr[left] + arr[right] < sum){
      left++;
    }else{
      right--;
    }
  }
  return 0;
}

  var resp = findSumOfArrayInGiven (arr, arrLen, sum);

  // Display Desired output
  if(resp.res === true){
    console.log('Matching Numbers are: ' + resp.matchNum +' = '+ sum);
  }else{
    console.log('There are no matching numbers of given sum');
  }

运行时测试JSBin：https://jsbin.com/vuhitudebi/edit?js,console

运行时测试JSFiddle：https://jsfiddle.net/arbaazshaikh919/de0amjxt/4/

Answer 12

function sumOfTwo(array, sumNumber) {
  for (i of array) {
    for (j of array) {
        if (i + j === sumNumber) {
            console.log([i, j])
        }
    }
  }
}
sumOfTwo([1, 2, 3], 4)

Answer 13

function twoSum(args , total) {
    let obj = [];
    let a = args.length;
    for(let i = 0 ; i < a ; i++){
        for(let j = 0; j < a ; j++){
                if(args[i] + args[j] == total) {
                    obj.push([args[i] , args[j]])
                } 

        }
    }
    console.log(obj)}

twoSum([10,20,10,40,50,60,70,30],60);
/* */

来自指定数组的元素对，其总和等于特定目标数

13 个答案:

让我们研究一下如何更好地理解它：

在迭代0中：

在迭代2中：