Мини-Макс Сумма в JavaScript - Как получить минимальную сумму и максимальную сумму из 4 элементов в массиве из 5 элементов

Question

Ссылка на вызов HackerRank

Моя идея состоит в том, чтобы циклически проходить по массиву и суммировать все элементы в массиве каждый раз, кроме одного, а затем находить наименьшую сумму и наибольшую сумму,

Я знаю, что .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, что бы вы предложили?

EDIT : теперь используйте 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

Ключ состоит в том, чтобы сначала отсортировать этот массив, затем минимум будет первым элементом, а максимум последним, следовательно, если вы хотите получить минимальный набор, это будет массив без наибольшего значения (последний элемент) и если вы хотите получить максимальный набор, это будет массив без наименьшего значения (первый элемент).

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 2

Вы можете получить минимальное и максимальное значения массива и отфильтровать массив, не принимая минимальное или максимальное значение один раз.

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 3

Задача HackerRank просто запрашивает суммы, поэтому вы можете сделать один проход через массив, чтобы вычислить 3 факта:

• Максимальный элемент (a)
• Минимальный элемент (b)
• Общая сумма всех элементов (c)

Сумма наименьшего куска будет c - a, а сумма наибольшегоbe 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

Это решение пересекает индексы срезов, вычисляет сумму и, когда найден максимум, вводится в результат. В итоге результат анализируется:

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

EDIT

Разумеется, более простое решение - найти минимум и рассчитать сумму без него.

Answer 5

Вы можете 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))