web-dev-qa-db-fra.com

Javascript: en utilisant réduire () pour trouver les valeurs min et max?

J'ai ce code pour une classe où je suis censé utiliser la méthode Reduce () pour trouver les valeurs min et max dans un tableau. Cependant, nous sommes tenus de n'utiliser qu'un seul appel pour réduire. Le tableau de retour doit être de taille 2, mais je sais que la méthode Reduce () renvoie toujours un tableau de taille 1. Je peux obtenir la valeur minimale en utilisant le code ci-dessous, mais je ne sais pas comment obtenir le valeur maximale dans ce même appel. Je suppose qu'une fois que j'obtiens la valeur maximale que je viens de pousser vers le tableau après la fin de la méthode Reduce ().

/**
 * Takes an array of numbers and returns an array of size 2,
 * where the first element is the smallest element in items,
 * and the second element is the largest element in items.
 *
 * Must do this by using a single call to reduce.
 *
 * For example, minMax([4, 1, 2, 7, 6]) returns [1, 7]
 */
function minMax(items) {
     var minMaxArray = items.reduce(
        (accumulator, currentValue) => {
             return (accumulator < currentValue ? accumulator : currentValue);
        }
    );

     return minMaxArray;
 }
javascriptarraysreduce
15
Alyssa June

L'astuce consiste à fournir un tableau vide comme paramètre initialValue

arr.reduce(callback, [initialValue])

initialValue [Facultatif] Valeur à utiliser comme premier argument du premier appel du rappel. Si aucune valeur initiale n'est fournie, le premier élément du tableau sera utilisé.

Ainsi, le code ressemblerait à ceci:

function minMax(items) {
    return items.reduce((acc, val) => {
        acc[0] = ( acc[0] === undefined || val < acc[0] ) ? val : acc[0]
        acc[1] = ( acc[1] === undefined || val > acc[1] ) ? val : acc[1]
        return acc;
    }, []);
}
9
colxi

Dans ES6 vous pouvez utiliser l'opérateur d'étalement. Solution à une chaîne:

 Math.min(...items)
15
Sergey Zhukov

Vous pouvez utiliser un tableau comme valeur de retour:

function minMax(items) {
    return items.reduce(
        (accumulator, currentValue) => {
            return [
                Math.min(currentValue, accumulator[0]), 
                Math.max(currentValue, accumulator[1])
            ];
        }, [Number.MAX_VALUE, Number.MIN_VALUE]
    );
}
6
Ilyas Kabirov

La solution utilisant les fonctions Math.min() et Math.max():

function minMax(items) {
    var minMaxArray = items.reduce(function (r, n) {
            r[0] = (!r[0])? n : Math.min(r[0], n);
            r[1] = (!r[1])? n : Math.max(r[1], n);
            return r;
        }, []);

    return minMaxArray;
}

console.log(minMax([4, 1, 2, 7, 6]));
3
RomanPerekhrest

Comme l'appel de réduction n'est pas vraiment nécessaire du tout, vous pouvez vous amuser avec

let items = [62, 3, 7, 9, 33, 6, 322, 67, 853];

let arr = items.reduce((w,o,r,k,s=Math)=>[s.min.apply(0, k),s.max.apply(0, k)],[]);

console.log(arr);

Tout ce dont vous avez vraiment besoin est let minMaxArray = [Math.min.apply(0,items), Math.max.apply(0,items)]

2
adeneo

1. Solution utilisant uniquement Math.min Et Math.max:

⚠️ Cela ne fonctionnera pas si vous utilisez de grands tableaux, c.-à-d. Fournissez Math.min() avec de nombreux arguments comme " vous courez le risque de dépasser la limite de longueur d'argument du moteur JavaScript . Les conséquences de l'application d'une fonction avec trop d'arguments (pensez à plus de dizaines de milliers d'arguments) varient selon les moteurs (JavaScriptCore a une limite d'arguments codée en dur de 65536), car la limite (en effet même la nature de tout comportement excessivement volumineux) n'est pas spécifiée. Certains moteurs lèveront une exception. "à partir des documents Web MDN .

function minMax(items) {
  return [
      Math.min.apply(null, items),
      Math.max.apply(null, items)
  ]
}

... ou si vous préférez syntaxe Spread d'ES6 :

const minMax = items => [
  Math.min(...items),
  Math.max(...items)
]

2. Solution utilisant Array.prototype.reduce, Math.min Et Math.max

function minMax(arr) {
  return arr.reduce(function(acc, cur) {
    return [
      Math.min(cur, acc[0]),
      Math.max(cur, acc[1])
    ]
  }, [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]);
}

... ou raccourci:

const minMax = items =>
  items.reduce((acc, cur) =>
    [Math.min(cur, acc[0]), Math.max(cur, acc[1])],
    [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]
  )

3. Solution comprenant des validations sensées

function minMax(items) {
  let newItems = []
  const isArray = Array.isArray(items)
  const onlyHasNumbers = !items.some(i => isNaN(parseFloat(i)))

  // only proceed if items is a non-empty array of numbers
  if (isArray && items.length > 0 && onlyHasNumbers) {
    newItems = items.reduce(function(acc, cur) {
      return [
        Math.min(cur, acc[0]),
        Math.max(cur, acc[1])
      ]
    }, [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])
  }
  return newItems
}

Documentation pour Math.min

Documentation pour Math.max

Documentation pour Array.prototype.reduce ()

0
tobias

Pour obtenir les valeurs min et max d'un tableau à l'aide de la fonction de réduction

const ArrayList = [1, 2, 3, 4, 3, 20, 0];
const LargestNum = ArrayList.reduce((prev, curr) => {
      return Math.max(prev, curr)
});
const MinNum = ArrayList.reduce((prev,curr)=>{
      return Math.min(pre,curr)
});
console.log(LargestNum);
console.log(MinNum);
0
Ahmed Mahmoud