Question

我试图解决一个基本的JavaScript算法，我有点卡住了，这就是问题：

给定一个整数数组，找到那对相邻的元素   拥有最大的产品并返回该产品。

实施例

对于inputArray = [3,6，-2，-5,7,3]，输出应为   adjacentElementsProduct（inputArray）= 21。

7和3生产最大的产品。

这是我的代码，我无法找到问题，但在测试中它说它返回null：

import re
res = [re.sub(r"\((.*)\)", r"-\1", x) for x in orig]

我的问题是什么以及我需要改变什么？

Answer 1

您最终想要做的是遍历数组排除最后一个成员，并将每个当前项目的产品与其下一个相邻成员的产品进行比较，直到目前为止找到的最大成员。< / p>

您可以使用.slice()和.reduce()。

＆＃13;

function adjacentElementsProduct(arr) {
  return arr.slice(0, -1)
            .reduce((max, n, i) => Math.max(max, n * arr[i + 1]), -Infinity)
}


console.log(adjacentElementsProduct([3, 6, -2, -5, 7, 3]));

＆＃13;

另一种解决方案是在执行相同的.map()后使用.slice()创建一系列产品，并将该数组的成员传递给Math.max。

＆＃13;

function adjacentElementsProduct(arr) {
  return Math.max(...arr.slice(0, -1).map((n, i) => n * arr[i + 1]))
}


console.log(adjacentElementsProduct([3, 6, -2, -5, 7, 3]));

＆＃13;

Answer 2

使用reduce我们可以简化代码量。

var a = [3, 6, -2, -2, 7, 3].reduce(function(a, b, i, arr){
  if (b*arr[i-1] > a)
  {
      a = b*arr[i-1];
  }

  return a;
})

console.log(a)

Answer 3

首先，您可以从索引1迭代到结尾，并使用i - 1和i作为相邻元素。然后你可以检查你是否在迭代中并取值，或者如果乘法大于旧值，则确定更大的乘积。

＆＃13;

function adjacentElementsProduct(inputArray) {
    var cb, i;
    for (i = 1; i < inputArray.length; i++) {
        if (i === 1 || inputArray[i - 1] * inputArray[i] > cb) {
            cb = inputArray[i - 1] * inputArray[i];
        }
    }
    return cb;
}

console.log(adjacentElementsProduct([3, 6, -2, -5, 7, 3]));

＆＃13;

Answer 4

您的代码问题是您从未初始化cb。因此，与cb的比较始终无效。这是您的代码的正确版本 -

function adjacentElementsProduct(inputArray) {
    var cb = Number.NEGATIVE_INFINITY;
    for(var i=0;i<inputArray.length-1;i++){
        if(inputArray[i]*inputArray[i+1] > cb){
          cb = inputArray[i]*inputArray[i+1];
        }
    }
  return cb;
}

console.log(adjacentElementsProduct([3, 6, -2, -5, 7, 7]))

Answer 5

由于您需要使用成对元素 - 您可以直接运行它并保持商店最大产品价值，如下所示：

function adjacentElementsProduct(items) {
    var product = 0;
    for (var i = 0; i < items.length - 1; i++) {
        product = Math.max(product, items[i] * items[i + 1]);
    }
    return product;
}

console.log(adjacentElementsProduct([3, 6, -2, -5, 7, 3]));

Answer 6

更多通用解决方案：这将适用于具有负数和非负数的每个数组。

int adjacentElementsProduct(int[] inputArray) {

    int length = inputArray.Length;
    int max = Number.NEGATIVE_INFINITY;

    for (int i = 0; i < length - 1; i++ ) {
        max = Math.Max(max, inputArray[i] * inputArray[i+1]);
    }

    return max;
}

Answer 7

int adjacentElementsProduct(std::vector<int> inputArray) {
    int n=inputArray.size();
 int p=1;
 int maxp=inputArray[0]*inputArray[1];
    for(int i=0;i<n-1;i++){
       p=inputArray[i]*inputArray[i+1]; 
       if(p>maxp){
           maxp=p;
       }       
    }
    
    return maxp;
}

Answer 8

您将在Python中执行以下操作：

 def adjacentElementsProduct(inputArray):
    max = inputArray[0]* inputArray[1]
    for i in range(0, len(inputArray)-1):
            if inputArray[i] * inputArray[i+1] > max :
                max = inputArray[i] * inputArray[i+1]
                i+1
            else:
                i+1
    return max

或者您也可以像这样一行：

def adjacentElementsProduct(inputArray):
    return max([inputArray[i] * inputArray[i+1] for i in range(len(inputArray)-1)])

Javascript：相邻元素产品算法

8 个答案: