Javascript 如何从一个数组中找到3个数字的组合，当它们相加时，等于另一个给定的数字

我有一个数组，里面有多个数字。我想让函数从数组中返回另一个最多3个数字的数组，当这些数字相加时，等于另一个数字

它也可以是1或2个数字，但第一个数字必须是可能的最高数字

e、 g:

var数组=[1,2,3,4,5,6,7,8,9,10]；
风险值：25；

期望输出：[10,10,5]

或

var数组=[1,2,3,4,5,6,7,8,9,10]；
变量编号：11；

期望输出：[10,1]

或

var数组=[1,2,3,4,5,6,7,8,9,10]；
var数：5；

期望输出：[5]

您可能会看到，我正在构建一个小型dart应用程序，用于计算您的点数。这是最后一部分，我需要展示哪种省道组合可以让你精确地达到0，而不管我投掷了多少省道

我可以循环使用我的数字并将它们放入一个数组中，但一旦组合需要在另一个数字之前有一个较小的数字，它就无法计算。代码如下：

//要添加的数字
var FinishingNumber=[60,57,54,51,50,48,45,42,40,39,38,36,34,33,32,30,28,27,26,25,24,22,21,20,19,18,17,16,15,14,12,11,10,9,8,7,6,5,4,3,2,1]；
//号码
var输出=167；
//最终结果的变量
var dartsToFinishArr=[]；
//调用我的函数
检查数组（）；
函数checkArray（）{
对于（var j=0；j0）{
对于（n=0；nHi）。
我试图解决它，我有这个代码，工作良好

<>我没有尝试过JavaScript编程，但是我有C++的解决方案代码，所以你可以检查算法：

int numbersList[10] = {1,2,3,4,5,6,7,8,9,10};
    int targetNumber;

    cout<<"Enter target number: ";
    cin>>targetNumber;

    int a=numbersList[9], b=numbersList[9], c=numbersList[9];

    if (a+b+c==targetNumber)
    {
        cout<<"Answer: a="<<a<<" b="<<b<<" c="<<c<<endl;
    } else {
        int aPos=9, bPos=9, cPos=9;
        for(int i=0 ; i<719 ; i++)
        {
            a = numbersList[aPos];
            b = numbersList[bPos];
            c = numbersList[cPos];
            if (a+b+c==targetNumber)
            {
                cout<<"Possible! a="<<a<<" b="<<b<<" c="<<c<<endl;
                //break;
            } else if (a+b+c>targetNumber)
            {
                if (cPos==0)
                {
                    if (bPos==0)
                    {
                        if (aPos==0)
                        {
                            cout<<"Not possible!"<<endl;
                            break;
                        } else {
                            aPos -=1;
                        }
                    } else {
                        bPos -=1;
                    }
                } else {
                    cPos -=1;
                }
            }
        }
    }

int numbersList[10]={1,2,3,4,5,6,7,8,9,10}；
int targetNumber；
小胡瓜数量；
INTA=数字列表[9]，b=数字列表[9]，c=数字列表[9]；
如果（a+b+c==目标编号）
{
cout以下是我用javascript解决您的问题的尝试：

// the numbers to add
var finishingNumbers = [60, 57, 54, 51, 50, 48, 45, 42, 40, 39, 38, 36, 34, 33, 32, 30, 28, 27, 26, 25, 24, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1];

// The number
var output = 167;

// The variable for the end result
var dartsToFinishArr = [];

for (let i = 0; i < finishingNumbers.length; i++) {
  const element1 = finishingNumbers[i];
  if (element1 === output) {
    dartsToFinishArr = [element1];
    return;
  }

  for (let j = 0; j < finishingNumbers.length; j++) {
    const element2 = finishingNumbers[j];
    if (element1 + element2 == output) {
      dartsToFinishArr = [element1, element2];
      return;
    }

    for (let k = 0; k < finishingNumbers.length; k++) {
      const element3 = finishingNumbers[k];
      if (element1 + element2 + element3 === output) {
        dartsToFinishArr = [element1, element2, element3];
        return;
      }
    }
  }
}

//要添加的数字
var FinishingNumber=[60,57,54,51,50,48,45,42,40,39,38,36,34,33,32,30,28,27,26,25,24,22,21,20,19,18,17,16,15,14,12,11,10,9,8,7,6,5,4,3,2,1]；
//号码
var输出=167；
//最终结果的变量
var dartsToFinishArr=[]；
for（设i=0；i

这似乎是一个相当典型的例子，我强烈建议您阅读整个博客文章，因为这将极大地提高您的编程技能

现在我们已经有了一个有效的解决方案，让我们来玩一玩吧！这个解决方案满足了您的需求，但是您注意到我有3个嵌套for循环。这不是很糟糕，但是如果您的需求更改为在您的解决方案中包含任意数量的数字，我的代码将很快在一堆复制和粘贴中爆炸。我们可以构建一个可以满足您的需求的解决方案吗在解决方案中计算数字的数量，并始终能够计算它？当然！这是一个完美的解决方案

以下是一个更复杂但更通用的解决方案：

// the numbers to add
var finishingNumbers = [60, 57, 54, 51, 50, 48, 45, 42, 40, 39, 38, 36, 34, 33, 32, 30, 28, 27, 26, 25, 24, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1];

// The number
var output = 167;

// The variable for the end result
var dartsToFinishArr = [];

// The maximum amount of numbers allowed in the solution;
const maxNumbers = 3;

function sum(total, element) {
  return total + element;
}

function recursiveSolution(possibleSolution) {
  for (let element of finishingNumbers) {

    // Special case when we haven't added anything to the solution yet
    var total = element;
    if (possibleSolution.length > 0) {
      total = possibleSolution.reduce(sum) + element;
    }

    if (total === output) {
      dartsToFinishArr = possibleSolution;
      dartsToFinishArr.push(element);

      //Solution found, return recursively.
      return true;
    }

    if (total < output && possibleSolution.length < maxNumbers - 1) {
      //There's room for more numbers, continue recursively
      const newPossibleSolution = possibleSolution.slice(0);
      newPossibleSolution.push(element);
      if (recursiveSolution(newPossibleSolution)) {
        //The recursion worked, return recursively.
        return true;
      }
    }
  }

  //We tried everything with the current possible solution. Let's backtrack one number and try the next one.
  return false;
}

// Start the recursion with an empty solution
recursiveSolution([]);

console.debug(dartsToFinishArr);

//要添加的数字
var FinishingNumber=[60,57,54,51,50,48,45,42,40,39,38,36,34,33,32,30,28,27,26,25,24,22,21,20,19,18,17,16,15,14,12,11,10,9,8,7,6,5,4,3,2,1]；
//号码
var输出=167；
//最终结果的变量
var dartsToFinishArr=[]；
//解决方案中允许的最大数量；
常数maxNumbers=3；
函数和（总计，元素）{
返回合计+元素；
}
函数递归解（可能解）{
for（let finishingNumbers元素）{
//当我们还没有向解决方案中添加任何内容时的特殊情况
var总=元素；
如果（可能的解析长度>0）{
总计=可能的解决方案。减少（总和）+元素；
}
如果（总===输出）{
dartsToFinishArr=可能的解决方案；
dartsToFinishArr.push（元素）；
//找到解决方案后，递归返回。
返回true；
}
if（总

现在，您可以修改maxNumbers，您可以得到任何您想要的解决方案！
下面的逻辑经过所有组合，直到找到满足总数的三个数字。如果它们满足总数，它还可以快捷方式到少于三个数


//要添加的数字
var FinishingNumber=[60,57,54,51,50,48,45,42,40,39,38,36,34,33,32,30,28,27,26,25,24,22,21,20,19,18,17,16,15,14,12,11,10,9,8,7,6,5,4,3,2,1]；
//号码
var输出=167；
console.log（find）值（fin
// the numbers to add
var finishingNumbers = [60, 57, 54, 51, 50, 48, 45, 42, 40, 39, 38, 36, 34, 33, 32, 30, 28, 27, 26, 25, 24, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1];

// The number
var output = 167;

// The variable for the end result
var dartsToFinishArr = [];

// The maximum amount of numbers allowed in the solution;
const maxNumbers = 3;

function sum(total, element) {
  return total + element;
}

function recursiveSolution(possibleSolution) {
  for (let element of finishingNumbers) {

    // Special case when we haven't added anything to the solution yet
    var total = element;
    if (possibleSolution.length > 0) {
      total = possibleSolution.reduce(sum) + element;
    }

    if (total === output) {
      dartsToFinishArr = possibleSolution;
      dartsToFinishArr.push(element);

      //Solution found, return recursively.
      return true;
    }

    if (total < output && possibleSolution.length < maxNumbers - 1) {
      //There's room for more numbers, continue recursively
      const newPossibleSolution = possibleSolution.slice(0);
      newPossibleSolution.push(element);
      if (recursiveSolution(newPossibleSolution)) {
        //The recursion worked, return recursively.
        return true;
      }
    }
  }

  //We tried everything with the current possible solution. Let's backtrack one number and try the next one.
  return false;
}

// Start the recursion with an empty solution
recursiveSolution([]);

console.debug(dartsToFinishArr);