Défi Max-Mn Sum JavaScript HackerRank

Question

Étant donné cinq entiers positifs, trouvez les valeurs minimale et maximale qui peuvent être calculées en additionnant exactement quatre des cinq entiers. Imprimez ensuite les valeurs minimales et maximales respectives sur une seule ligne de deux entiers longs séparés par des espaces.

Par exemple var arr = [1,3,5,7,9] la sortie sera de 16 24.

Voici ma solution, tout fonctionne sauf un cas : lorsque tous les éléments du tableau sont égaux, ma solution renvoie une erreur. Comment puis-je le corriger ?

function miniMaxSum(arr) {
    let largest = arr[0];
    let smallest = arr[0];
    let largestSum = 0;
    let smallestSum = 0;
    for(let i = 0; i < arr.length; i ++){
      if(arr[i] > largest){
        largest = arr[i];
      }
      if (arr[i] < smallest){
        smallest = arr[i];
      }
    }
    for(let j = 0; j < arr.length; j ++){
      if(arr[j] < largest){
        smallestSum = smallestSum + arr[j];
      }
      if(arr[j] > smallest){
        largestSum = largestSum + arr[j];
      }
    }
    console.log(smallestSum + " " + largestSum)
}

Answer 1

Vous pourriez prendre la première valeur comme valeur de départ pour sum , min y max et itérer à partir du deuxième élément. Ensuite, ajoutez la valeur réelle et vérifiez min y max et de procéder à des ajustements.

A la fin, retournez le delta de sum y max y sum y min .

function minMaxSum(array) {
    var sum = array[0],
        min = array[0],
        max = array[0];

    for (let i = 1; i < array.length; i++) {
        sum += array[i];
        if (min > array[i]) min = array[i];
        if (max < array[i]) max = array[i];
    }

    return [sum - max, sum - min];
}

console.log(minMaxSum([1, 3, 5, 7, 9]));

Answer 2

Using ES6:

let numbers = [3,1,5,9,7]

let ascending = JSON.parse(JSON.stringify(numbers)).sort((a, b) => a - b)
ascending.pop()
let min = ascending.reduce((a, b) => a + b)

let descending = JSON.parse(JSON.stringify(numbers)).sort((a, b) => b - a)
descending.pop()
let max = descending.reduce((a, b) => a + b)

console.log(`${min} ${max}`)

OU

let numbers = [3,1,5,9,7]

let sum = numbers.reduce((a, b) => a + b)

let maxNumber = Math.max(...numbers)
let minNumber = Math.min(...numbers)

console.log(`${sum - maxNumber} ${sum - minNumber}`)

Answer 3

La solution est simple, il suffit de récupérer les valeurs min et max, de faire la somme du tableau et d'extraire min ou max afin d'obtenir la somme max ou la somme min.

En tant que pseudo-océde :

min_value = find_min_value(arr)
max_value = find_max_value(arr)
max_sum = sum_array(arr) - min_value
min_sum = sum_array(arr) - max_value

:)

Answer 4

Voici une fonction qui résout votre problème.

const minMaxSum = (arr) => {
    const orderedAr = arr.sort((a, b) => a - b);
    const min = orderedAr
        .slice(0, 4)
        .reduce((val, acc) => acc + val, 0);
    const max = orderedAr
        .slice(-4)
        .reduce((val, acc) => acc + val, 0);
    return `${min} ${max}`;
};

Answer 5

Voici le code complet plus optimisé et nettoyé avec tous les cas de test qui fonctionnent Utilisation de Arrays.sort()

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

// Complete the miniMaxSum function below.
   static void miniMaxSum(int[] arr) 
    {
       int min=0;
       int max=0;

       Arrays.sort(arr);

       for(int i=0; i<arr.length;i++)
       {
          if(i>0)
          {
             max+=arr[i];
          }
          if(i<4)
          {
            min+=arr[i];
          }
       }
      System.out.println(min + " " + max);
   }

   private static final Scanner scanner = new Scanner(System.in);

   public static void main(String[] args) 
   {
     int[] arr = new int[5];

     String[] arrItems = scanner.nextLine().split(" ");
     scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

     for (int i = 0; i < 5; i++) 
     {
        int arrItem = Integer.parseInt(arrItems[i]);
        arr[i] = arrItem;
     }

     miniMaxSum(arr);
     scanner.close();
  }
}