Question

我的想法是循环遍历数组，每次对数组中除一个元素之外的所有元素求和，然后找到最小和最大。

我知道.splice()可以从数组中删除任何元素。但是目前，使用我的代码，它只能从数组一次中删除一个元素。即这只给了我一大块：

function miniMaxSum(arr) {

  let smallestSum = 0;
  let largestSum = 0;

  for (let i = 0; i < arr.length; i++) {
    let chunk = arr.splice(1);
    console.log(chunk);
    if (chunk > largestSum) largestSum = chunk;
    if (chunk < smallestSum) smallestSum = chunk;
  }
  return (smallestSum, largestSum);
}

循环时，我需要每次从数组中删除一个元素，然后从该数组中获取最大和最小和。

对于给定的[1, 2, 3, 4, 5]

数组

我应该获得以下可能的“块”：

[2, 3, 4, 5]，[1, 3, 4, 5]，[1, 2, 4, 5]，[1, 2, 3, 5]，[1, 2, 3, 4]。

总和最高的块是[2, 3, 4, 5]

总和最小的块是[1, 2, 3, 4]。

如何调整代码以获取给定数组中所有可能的4位数组，以便仍可以使用for循环比较它们的总和？或者，如果没有for循环，您还会建议什么？

编辑：现在使用Math.min()和Math.max()获取数组中最小和最大的元素。然后使用.filter()删除那些元素以创建新的数组。然后获得这些数组的和。

function miniMaxSum(arr) {

  let smallest = Math.min(...arr);
  let largest = Math.max(...arr);

  let smallestArray = arr.filter(element => element !== largest);
  let largestArray = arr.filter(element => element !== smallest);

  let sumOfSmallestArray = 0;
  let sumOfLargestArray = 0;

  for (let i = 0; i < smallestArray.length; i++) {
    sumOfSmallestArray += smallestArray[i];
  }

  for (let i = 0; i < largestArray.length; i++) {
    sumOfLargestArray += largestArray[i];
  }

  return ([sumOfSmallestArray, sumOfLargestArray]).toString();
}

但是，即使它可以在我的控制台中使用，也不能在HackerRank中使用。

Answer 1

您可以获取数组的最小值和最大值，并通过一次不获取最小值或最大值来过滤数组。

var data = [1, 2, 3, 4, 5],
    min = Math.min(...data),
    max = Math.max(...data),
    dataMin = data.filter(v => v !== min || !(min = -Infinity)),
    dataMax = data.filter(v => v !== max || !(max = Infinity));

console.log(...dataMin);
console.log(...dataMax);

更经典的方法

function minMax(array) {
    var min = array[0],
        max = array[0],
        sum = array[0],
        i, v;
    
    for (i = 1; i < array.length; i++) {
        v = array[i];
        sum += v;
        if (v > max) max = v;
        if (v < min) min = v;
    }
    console.log(sum - min, sum - max);
}

minMax([1, 2, 3, 4, 5]);

Answer 2

关键是首先对该数组进行排序，然后最小值将是第一个元素，最大值将是最后一个元素，因此，如果要获取最小值集，它将是没有最大值的数组（最后一个元素）），如果要获得最大的设置，它将是没有最小值（第一个元素）的数组。

let data = [1, 3, 2, 4, 5];

// sort first
data = data.sort();
  
// to get the sets only
let maxSet = data.slice(1);
let minSet = data.slice(0, -1);

console.log(minSet, maxSet);

// to get just the max/min value
const sum = data.reduce((a, total) => a + total, 0);
console.log(sum - data[data.length - 1], sum - data[0]);

Answer 3

HackerRank挑战仅要求的总和，因此您可以遍历数组以计算3个事实：

最大元素（a）
最小元素（b）
所有元素的总和（c）

最小块的总和为c - a，最大块的总和为c - b。

这是使用reduce的单线解决方案：

var arr = [1, 2, 3, 4, 5];

var [a, b, c] = arr.reduce(([a, b, c], x) => [a > x ? a : x, b < x ? b : x, c + x], [NaN, NaN, 0]);
console.log(c - a, c - b);

注意：NaN只是在这里强制初始条件（a > x / b < x为假）

Answer 4

您可以sort数组，对于min，取前四个并添加它们；对于max，取后四个并添加它们

let arr = [1, 2, 3, 4, 5]
let minAndMax = (arr) => {
  arr = arr.sort((a,b) => a - b)
  let op = {}

  op.minArr = arr.slice(0,4)
  op.min = op.minArr.reduce((a,b) => a+b, 0)
  
  op.maxArr =  arr.slice(arr.length-4,) 
  op.max = op.maxArr.reduce((a,b) => a + b ,0)
  return op
}


console.log(minAndMax(arr))

Answer 5

此解决方案遍历切片索引，计算总和，当找到最大值时，将其求和。最终结果被解析：

var arr = [4, 8, 2, 6, 12];
var ln = arr.length;
var maxSum = undefined;
var result = "";
for (var splIndex = 0; splIndex < ln; splIndex++) {
    var item = arr.splice(splIndex, 1);
    var sum = 0;
    for (var it of arr) sum += it;
    if ((maxSum === undefined) || (maxSum < sum)) {
        maxSum = sum;
        result = JSON.stringify(arr);
    }
    arr.splice(splIndex, 0, item[0]);
}
console.log(JSON.parse(result));

编辑

一个更简单的解决方案，当然是找到最小值并计算没有该最小值的总和。

Answer 6

let arr = [15 ,12, 33, 25, 4];
//sort array
const arrSort = arr.sort((a,b)=> a-b );
console.log(arrSort);
//get values and sum 
var max = arrSort.filter(value => value < Math.max(...arrSort)).reduce((ac,at)=>{
    ac += at;
    return ac; 
},0);
var min = arrSort.filter(value => value > Math.min(...arrSort)).reduce((ac,at)=>{
    ac += at;
    return ac; 
},0);
console.log(max);
console.log(min);

Answer 7

这对我有用。

process 1

Answer 8

以下功能有效：

function miniMaxSum(arr) {
    var _arr = arr.sort((a, b) = > a - b)
    var minVals = _arr.slice(0, 4)
    var maxVals = _arr.slice(1)
    const arrSum = __arr = > __arr.reduce((a, b) = > a + b, 0)
    var minSum = arrSum(minVals)
    var maxSum = arrSum(maxVals)
    console.log(minSum, maxSum)
}

Answer 9

我以非常简单的方式得到答案

function miniMaxSum(arr) {
let minval=arr[0];
let maxval=0;
let totalSum=0;
for(let i=0;i<arr.length;i++){
    if (arr[i]>maxval){
        maxval=arr[i];
    }
    if (arr[i]<minval){
        minval=arr[i];
    }
    totalSum=totalSum+arr[i];
    
}

let minsum=totalSum - maxval;
let maxsum=totalSum - minval;

console.log( minsum,maxsum);

}

JavaScript中的最小最大和-如何获取5元素数组中4个元素的最小和最大

9 个答案: