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

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

这是我的密码

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;
};

函数邻接元素产品（输入阵列）{
var arr=输入阵列；
var x=0；
var y=0；
var p=0；
对于（var i=0；i
），可以从一个非常大的负值开始，而不是从零开始

var p = -Infinity;

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

var p = Number.MIN_SAFE_INTEGER;


函数邻接元素产品（输入阵列）{
var arr=输入阵列；
var x=0；
var y=0；
var p=Number.MIN\u SAFE\u整数；
对于（变量i=0；ip）{
p=x*y；
};
};
返回p；
};
console.log（AdjaceEntelementsProduct（[-23,4，-3,8，-12]））；
您可以尝试在函数内创建一个新的长度数组（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]));

函数邻接元素产品（输入阵列）{
var arr=输入阵列；
var-prodArr[]；
var-p；
对于（变量i=0；ip）{
p=prodArr[j]；
};
返回p；
};
log（邻接元素产品（[-23,4，-3,8，-12]）；
这是一个非常简单的实现，不使用任何附加变量（实际上更少），也没有特殊值。只是简单的逻辑


函数邻接元素产品（输入阵列）{
var c=输入阵列[0]*输入阵列[1]；
var p=c；
对于（变量i=1；i p）{
p=c；
};
};
返回p；
};
log（“minimum product=“+adjacentElementsProduct（[-23,4，-3,8，-12]））；
这实际上非常简单

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;
}

函数邻接元素产品（输入阵列）{
设max=-无穷大；
for（设i=1；i
保存最大乘积的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;
        }

static void Main（字符串[]args）
{
int[]arr={1，-4,3，-6，-7,0}；
控制台写入线（FindMaxProduct（arr））；
Console.ReadKey（）；
}
静态int FindMaxProduct（int[]arr）{
int currentProduct=0；
int maxProduct=int.MinValue；
int a=0，b=0；
对于（int i=0，j=i+1；imaxProduct）{
a=arr[i]；
b=arr[j]；
maxProduct=currentProduct；
}
}
WriteLine（“最大乘积是{0}，两个num是{1}和{2}.”，maxProduct，a，b）；
退货产品；
}
这应该有帮助，用python编写。概念：传递一个空列表，对于每个连续的产品，保持将其存储在列表中。然后只返回最大值

def连续_产品_最大值（a）：
lst2=[]
对于范围（0，len（a）-1）内的i：
x=a[i]*a[i+1]
lst2.追加（x）
返回最大值（lst2）
您可以尝试将整数初始化为负无穷大值-math.inf，然后使用python三元运算符var=true，如果条件为false，则查找最大值

用python编写代码

def邻接阵列（a）：
最大值=-math.inf
对于i，范围为（0，len（a）-1）：
最大值=a[i]*a[i+1]如果a[i]*a[i+1]>最大值
返回最大值

在javascript中编写代码

函数邻接元素产品（a）{
var最大值=-无穷大；
对于（var i=0；imaximum？a[i]*a[i+1]：最大值；
}
返回最大值；
}
该循环的最后一次迭代将
y
设置为
arr[arr.length]
，这不是一个有效的索引。嗨，这个代码似乎不是javascript，因为问题在标题中被标记和提示。你能将代码改编成javascript吗？嗨@niccord，我也用javascript更新了代码