Javascript 从整数的k中可以得到的最高乘积

我正在处理以下问题：

给定一个ArrayFints，从整数的k中找出你能得到的最高乘积

这是我到目前为止提出的解决方案，基于从3个整数中得到最高乘积的推广

var getHighestProductOfk = function (arrayOfInts, k) {
  if (arrayOfInts.length < k) {
    throw Error('Array should be higher than k');
  }

  highestProductArray = [arrayOfInts[0]];
  lowestProductArray = [arrayOfInts[0]];

  for (let i=1; i<k; i++) {
    highestProductArray[i] = highestProductArray[i-1]*arrayOfInts[i];
    lowestProductArray[i] = lowestProductArray[i-1]*arrayOfInts[i];
  }

  for(let i=1; i<arrayOfInts; i++) {
    let currentInt = arrayOfInts[i];

    for(let j=k-1; j>=0; j--) {
      highestProductArray[j] = Math.max(
        highestProductArray[j],
        highestProductArray[j-1]*currentInt,
        lowestProductArray[j-1]*currentInt
      );

      lowestProductArray[j] = Math.min(
        lowestProductArray[j],
        lowestProductArray[j-1]*currentInt,
        highestProductArray[j-1]*currentInt
      );
    }

    // highest number
    highestProductArray[0] = Math.max(highestProductArray[0], currentInt)

    // lowest number
    lowestProductArray[0] = Math.max(lowestProductArray[0], currentInt)
  }

  return highestProductArray[k-1];
}

var getHighestProductOfk=函数（arrayOfInts，k）{
if（arrayOfInts.length对于（让i=1；i这里有一个想法。对数字进行排序。接下来，尽可能多地从最大的正数中选择，最多为
k
。现在从最小的负数中选择最大的偶数组，它们形成了比最小正数更大的乘积，我们将用它们替换。（存在一些边缘情况，例如只有一个负值和
k-1
正值）

根据我的初步想法，我建议对值进行升序排序，如果计数为奇数，则取最高值，其余值成对使用

这将保持一个带循环的正积，直到使用了所有需要的因子

在带有计数检查的while循环中，如果乘积大于数组开头的乘积，则选择对。这包括负数，但也仅适用于正数或负数


函数getHighestProductOfK（a，k）{
var p=1；
a、 排序（函数（a，b）{返回a-b；}）；
如果（k>a.length | k&2&&a[a.length-1]<0）{
返回；
}
如果（k%2）{
p=a.pop（）；
k--；
}
while（k）{
p*=a[0]*a[1]>a[a.length-2]*a[a.length-1]？a.shift（）*a.shift（）：a.pop（）*a.pop（）；
k-=2；
}
返回p；
}
log（getHighestProductOfK（[1,10，-5,1，-100]，3））；
log（getHighestProductOfK（[3,4,5,6,7,3]）；
log（getHighestProductOfK（[-3，-4，-5，-6，-7]，3））；
log（getHighestProductOfK（[3,4，-5，-6，-7]，3））；

需要一些测试来确保它总是给出好的答案

function largestProduct(k, arr) {
    if (k > arr.length) throw new RangeError('Not enough numbers');

    let pos = [],
        neg = [];
    arr.forEach(e => {
        if (e >= 0) pos.push(e);
        else neg.push(e);
    });
    pos.sort((a, b) => a < b); //  9,  8,  7, ...
    neg.sort((a, b) => a > b); // -9, -8, -7, ...

    if (pos.length === 0 && k % 2) // k requires odd number of negatives
        return neg.slice(-k); // give the smallest number TODO: same return

    let big = [];
    while (k > 1) grow();
    if (k === 1) { // we've reached the end of doubles but still need more
        if (pos.length) big.push(pos[0]);
        else { // ran out of positives, backtrack
            big = big.slice(0, -1);
            big.push(neg[0], neg[1]);
        }
    }

    return {
        factors: big,
        product: big.reduce((a, b) => a * b, 1)
    };

    function grow() { // choose the next best number
        let doublepos = pos[0] * pos[1],
            doubleneg = neg[0] * neg[1];
        if (doublepos > doubleneg || doubleneg !== doubleneg) {
            big.push(pos[0]);
            pos = pos.slice(1);
            k -= 1;
        } else {
            big.push(neg[0], neg[1]);
            neg = neg.slice(2);
            k -= 2;
        }
    }
}

功能最大的产品（k，arr）{
如果（k>arr.length）抛出新的RangeError（'数字不够'）；
设pos=[]，
负=[]；
arr.forEach（e=>{
如果（e>=0）位置推（e）；
否则为负推力（e）；
});
pos.sort（（a，b）=>aa>b）；/-9，-8，-7。。。
if（pos.length==0&&k%2）//k需要奇数个负片
return neg.slice（-k）；//指定要执行的最小数字：相同的返回
让大=[]；
而（k>1）增长（）；
如果（k==1）{//我们已经到了双打的终点，但还需要更多
如果（位置长度）较大，则推动（位置[0]）；
否则{//就没有积极的方面了，回溯一下
大=大。切片（0，-1）；
big.push（负[0]，负[1]）；
}
}
返回{
因素:大,，
产品：大。减少（（a，b）=>a*b，1）
};
函数grow（）{//选择下一个最佳数字
设doublepos=pos[0]*pos[1]，
双负=负[0]*负[1]；
如果（doublepos>doubleneg | | doubleneg！==doubleneg）{
大.推（位置[0]）；
位置=位置切片（1）；
k-=1；
}否则{
big.push（负[0]，负[1]）；
负=负切片（2）；
k-=2；
}
}
}

我认为您应该只使用第一个数字初始化两个数组（否则您将不得不调整循环，因为

highestProductArray[2]

仅在etc上的位置2有效）。此外，访问

highestProductArray[j-1]

对于

j=0

无效。我认为，您可以对项目进行排序，在数组两端取两组并进行检查。如果更大，则取下它们并继续执行。@NinaScholz开始编写解决方案，结果证明（除非我错过了一个技巧）它比最初出现的要复杂得多；如果你需要取的数字多于正数，会发生什么情况？你需要跟踪哪些数字来自双负数。如果你被迫取奇数个负数，会发生什么情况？你实际上希望所有数字都接近零。计算产品可能更容易整个阵列的ct，如果是负片，移除最小负片，如果是正片，移除最小的正片或两个最小的负片，重复，直到剩下

k

个数。如果仍然是负片，则将最小的正片替换为最小的剩余负片。如果需要取奇数的如果是否定的，请尽早抓住这一点，并为所有内容选择最接近零的值

Pick 3 from [1, 10, -5, 1, -100]

Sort => [-100,-5,1,1,10]

Pick largest positives => 10 * 1 * 1

Pick largest even number of smallest negatives we can,
whose product is greater than the one replaced

  => (-100) * (-5) > 1 * 1

Answer => 10 * (-100) * (-5)

function largestProduct(k, arr) {
    if (k > arr.length) throw new RangeError('Not enough numbers');

    let pos = [],
        neg = [];
    arr.forEach(e => {
        if (e >= 0) pos.push(e);
        else neg.push(e);
    });
    pos.sort((a, b) => a < b); //  9,  8,  7, ...
    neg.sort((a, b) => a > b); // -9, -8, -7, ...

    if (pos.length === 0 && k % 2) // k requires odd number of negatives
        return neg.slice(-k); // give the smallest number TODO: same return

    let big = [];
    while (k > 1) grow();
    if (k === 1) { // we've reached the end of doubles but still need more
        if (pos.length) big.push(pos[0]);
        else { // ran out of positives, backtrack
            big = big.slice(0, -1);
            big.push(neg[0], neg[1]);
        }
    }

    return {
        factors: big,
        product: big.reduce((a, b) => a * b, 1)
    };

    function grow() { // choose the next best number
        let doublepos = pos[0] * pos[1],
            doubleneg = neg[0] * neg[1];
        if (doublepos > doubleneg || doubleneg !== doubleneg) {
            big.push(pos[0]);
            pos = pos.slice(1);
            k -= 1;
        } else {
            big.push(neg[0], neg[1]);
            neg = neg.slice(2);
            k -= 2;
        }
    }
}