如何使用数字数组使用Java中的reduce函数返回最高和最低数字

Question

How do I take an array of numbers and return both the highest and the lowest number using the reduce function in Javascript?

My attempt so far:

 function each(collection, callback) {
    if(Array.isArray(collection)) {
       for(var i = 0; i < collection.length; i++) {     
           callback(collection[i]);
    }
  } else {
    for(var prop in collection) {
        callback(collection[prop]);
    }
}
}

function reduce(collection, callback, initial) {
each(collection, function(element) {
    if(initial === undefined) {
        initial = element;
    } else {
        initial = callback(initial, element);
    }
});
return initial;
}

function highAndLow(collection) {
//use reduce
return reduce(collection, function(initial, element){
    if(initial[element] > initial[element]){
        initial = "high: " + element;
    } else {
        initial = "low: " + element
    }
    return initial;
}, {})
}

highAndLow([5,2,1,6,8])

The results are supposed to look like this: highAndLow(5, 2, 1, 6, 8) === { low: 1, high: 8 }

Answer 1

Yes, it is possible, for example with this code

 function highAndLow(array) { return array.reduce(function (r, a) { return { low: Math.min(r.low, a), high: Math.max(r.high, a) }; }, { low: array[0], high: array[0] }); } document.write('<pre>' + JSON.stringify(highAndLow([5, 2, 1, 6, 8]), 0, 4) + '</pre>'); document.write('<pre>' + JSON.stringify(highAndLow([]), 0, 4) + '</pre>'); document.write('<pre>' + JSON.stringify(highAndLow([-2, .1, 0, 1, 2]), 0, 4) + '</pre>'); 

Answer 2

function highAndLow() = {
   var args = Array.prototype.call(arguments);
   var low = Infinity;
   var high = -Infinity;
   args.forEach(function (arg) {
      if (arg < low) {
          low = arg;
      }
      if (arg > high) {
          high = arg;
      }
   });
   return {
       low: low,
       high: high
   }
}

or

function highAndLow() {
    return Array.prototype.call(arguments).reduce(function (hash, arg) {
        hash.low = arg < hash.low ? arg : hash.low;
        hash.high = arg > hash.high ? arg : hash.high;
        return hash;
    }, {
       low: Infinity,
       high: -Infinity
    });
}

Answer 3

Here is a solution:

[-30, 30, 1, 10000, -20, 50, 0].reduce(function(acc, n) {
  if (n < acc.min) {
      return {
        min: n,
        max: acc.max
      }
  }
  if (n > acc.max) {
      return {
        min: acc.min,
        max: n
      }
  }
  return acc
}, {min: Infinity, max: -Infinity})

// {
//   max: 10000,
//   min: -30
// }

We supply an initial value {min: Infinity, max: -Infinity} , with a min which is >= any value we will encounter, and a max which is <= any value we will encounter.

Then we write our reducing function, which must takes a value like our initial value, and the a value provided by the array. In our case {min, max} and Number . Our function simply compares input numbers with the max and min values from the array ensuring that we always return an object with the same properties, max and min .

These are the basic requirements for any use of reduce .

Incidentally, we can take a very functional and concise approach with es6.

[-30, 30, 1, 10000, -20, 50, 0].reduce(({min, max}, n) => ({
  min: n < min ? n : min,
  max: n > max ? n : max
}), {min: Infinity, max: -Infinity})

Answer 4

With any number of arguments as specified, below can work

function highAndLow() {
  var inputArr = Array.prototype.slice.call(arguments);
  return inputArr.reduce(function(res, num) {
    if (res === null){
    res = {high:num,low:num};
    }
    if (num > res.high) {
      res.high = num;
    }
    if (num < res.low) {
      res.low = num;
    }
    return res;
  }, null);
}

highAndLow(5, 2, 1, 6, 8) //{high: 8, low: 1}