Somme mini-max en JavaScript - Comment obtenir la somme minimale et la somme maximale de 4 éléments dans un tableau de 5 éléments

Cette solution parcourt les index des tranches, calcule la somme et lorsqu'un maximum est trouvé, elle est mise en résultat. Enfin le résultat est analysé:

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

Une solution plus simple, bien sûr, est de trouver le minimum et de calculer la somme sans lui.

Le défi HackerRank ne demande que les sommes du, donc vous pouvez faire un passage dans le tableau pour calculer 3 faits:

• Élément maximum ( a )
• Élément minimum ( b )
• Somme totale de tous les éléments ( c )

La somme du plus petit morceau sera c - a et la somme du plus grand sera c - b .

Voici une solution unique utilisant réduire :

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

Note: les NaN sont juste là pour forcer les conditions initiales ( a> x / b être faux)

La clé est de trier ce tableau en premier, puis le minimum sera le premier élément et le maximum sera le dernier, donc si vous voulez obtenir l'ensemble minimum, ce sera le tableau sans la valeur la plus élevée (dernier élément ) et si vous voulez obtenir l'ensemble maximum, ce sera le tableau sans la valeur la plus basse (premier élément).

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

La fonction suivante fonctionne:

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

Cela a fonctionné pour moi.

let minValue, maxValue
const ascendingArray = arr.sort((a,b) => a - b)

const smallestNumber = ascendingArray[0]
const biggestNumber = ascendingArray[ascendingArray.length -1]

if(smallestNumber !== biggestNumber){

    const biggestArray = arr.filter((number) => {
        return number !== smallestNumber
     })

     const smallestArray = arr.filter((number) => {
         return number !== biggestNumber
      })

     minValue = smallestArray.reduce((a,b) => a + b, 0)
     maxValue = biggestArray.reduce((a,b) => a + b, 0)
     console.log(minValue, maxValue);
}
else{
    const arraySliced = arr.slice(0, 4)

    const value = arraySliced.reduce((a,b) => a + b, 0)
    console.log(value, value);
}    

J'obtiens une réponse de manière très simple

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

}