Question

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

这是我的代码

function adjacentElementsProduct(inputArray) {
 var arr = inputArray;
  var x=0;
  var y=0;
  var p=0;
  for(var i=0;i<arr.length;i++){
    x=arr[i];
    y=arr[i+1];
    if(x*y>p){
     p=x*y;
    };
  };
 return p;
};

问题是所有测试都运行良好但除了带负片的数组，如附图所示任何人都可以帮助..并提前感谢

enter image description here

Answer 1

你可以从一个非常大的负值开始，而不是零。

var p = -Infinity;

Answer 2

您正在将变量p初始化为零。这意味着不接受任何小于该值的乘法值。而是将其设置为可能的最小整数值：

var p = Number.MIN_SAFE_INTEGER;

function adjacentElementsProduct(inputArray) {
  var arr = inputArray;
  var x = 0;
  var y = 0;
  var p = Number.MIN_SAFE_INTEGER;
  for (var i = 0; i < arr.length; i++) {
    x = arr[i];
    y = arr[i + 1];
    if (x * y > p) {
      p = x * y;
    };
  };
  return p;
};

console.log(adjacentElementsProduct([-23, 4, -3, 8, -12]));

Answer 3

您可以尝试在函数内创建一个新的长度数组（arr.length-1），并将相邻数字的乘积附加到此新数组中。然后找到数组中的最大数字并返回它。这将解决负面产品的问题。

function adjacentElementsProduct(inputArray) {
  var arr = inputArray;
  var prodArr[];
  var p;
  for (var i = 0; i < arr.length-1; i++) {
    prodArr[i] = arr[i]*arr[i+1];
  };
  for (j=prodArr.length; j--){
  if (prodArr[j] > p) {
      p = prodArr[j];
    };
  return p;
};

console.log(adjacentElementsProduct([-23, 4, -3, 8, -12]));

Answer 4

这是一个非常简单的实现，不使用任何其他变量（实际上更少），也没有特殊值。只是简单的逻辑。

＆＃13;

function adjacentElementsProduct(inputArray) {
    var c =inputArray[0]*inputArray[1];
    var p = c;
    for(var i=1;i<inputArray.length;i++){
        console.log(c);
        var c=inputArray[i]*inputArray[i+1];
        if(c > p){
            p=c;
        };
    };
    return p;
};
console.log("minimum product = " + adjacentElementsProduct([-23,4,-3,8,-12]));

＆＃13;

我所做的是，使用数组的前两个元素的乘积初始化变量c（当前产品）。然后我声明变量p并将其初始化为c。这样，所有其他产品都与此产品进行了比较。休息很简单。

希望它有所帮助。：）

Answer 5

实际上这很简单

function adjacentElementsProduct(inputArray) {
    let max = -Infinity;
    for (let i = 1; i < inputArray.length; i++) {
        max = Math.max(inputArray[i] * inputArray[i - 1], max);
    }

    return max;
}

Answer 6

保存最大乘积的varp应该初始化得尽可能小，而不是一个0。这样当乘积为负时，它仍然满足if条件并保存该值。这是一个 C# 解决方案：

 static void Main(string[] args)
        {
            int[] arr = { 1, -4, 3, -6, -7, 0 };
            Console.WriteLine(FindMaxProduct(arr));
            Console.ReadKey();
        }
 static int FindMaxProduct(int[] arr) {
            int currentProduct = 0;
            int maxProduct = int.MinValue;
            int a=0, b = 0;
            for (int i = 0, j = i + 1; i < arr.Length - 1 && j < arr.Length; i++, j++)
            {
                currentProduct = arr[i] * arr[j];
                if (currentProduct>maxProduct) {
                    a = arr[i];
                    b = arr[j];
                    maxProduct = currentProduct;
                }
            }
            Console.WriteLine("The max product is {0}, the two nums are {1} and {2}.",maxProduct,a,b);
            return maxProduct;
        }

Answer 7

这应该有帮助，用python写的。概念：传递一个空列表，对于每个连续的产品，将其存储在列表中。然后只返回最大值。

def consecutive_product_max(a):
    lst2 = []
    for i in range(0, len(a)-1):
        x = a[i] * a[i+1]
        lst2.append(x)
    return max(lst2)

Answer 8

您可以尝试将整数初始化为负无穷大值-math.inf，然后使用 python 三元运算符 var=true if condition else false< /strong> 求最大值

python
中的代码
def adjacentarray(a): maximum=-math.inf for i,in range(0,len(a)-1): maximum=a[i]*a[i+1] if a[i]*a[i+1]>maximum else maximum return maximum

javascript
中的代码
function adjacentElementsProduct(a) { var maximum=-Infinity; for (var i=0;i<a.length-1;i++){ maximum= a[i]*a[i+1]>maximum?a[i]*a[i+1]:maximum; } return maximum; }

给定一个整数数组，找到具有最大乘积的相邻元素对并返回该乘积

8 个答案: