Javascript根据数组本身在2D数组中找到最大值

Question

I've a multidimensional array

arr = [[[1,1],[2,1],[3,1],[4,2],[5,2],[6,2],[7,3],[8,4]],
       [[1,1],[2,1],[3,1],[4,3],[5,3],[6,4],[7,4],[8,5],[9,5],[10,5]]
      ];

and so on ... but the dimension of the arr is not fixed, is variable.

I've a variable that tell me where to point my attention

var number = 2;

So my goal is the look in any arr[i] and find the max 1st argument based on the 2nd argument, I try to explain better my self, in this particular case if number is 2 my expectation is to have from arr: for the 1st array in arr -> 6 (because the second argument is 1,1,1,2,2,2,3 so I've to point at the last 2 and return the 1st argument) for the 2nd array in arr -> 3 (because 2 is missing and the 1 is the last second argument)

I know is a little tricky

My first idea was to make a for loops where I delete all value over my number, then I can take the very last one, but I think I'm over-complicating all.

There is a better and fast way to achieve the same result?

J

Answer 1

You present lists (arrays) of pairs of numbers, where the pairs are sorted in ascending order, first by the second number, then by the first.

What you seem to ask for is: Given a number to search for among the second numbers, eg number = 2 , find the last pair where the second number is less than or equal to this number, and return the corresponding first number in this pair.

You state that you could use for loops to solve the problem. A straightforward approach could be like the following snippet:

 var arr = [[[1,1],[2,1],[3,1],[4,2],[5,2],[6,2],[7,3],[8,4]], [[1,1],[2,1],[3,1],[4,3],[5,3],[6,4],[7,4],[8,5],[9,5],[10,5]] ]; var findNumber = 2; var result = []; for(var i = 0; i < arr.length; i++){ var maxIndex = -1; for(var j = 0; j < arr[i].length && arr[i][j][1] <= findNumber; j++){ maxIndex = j; } result.push(arr[i][maxIndex][0]); } //gives the expected answers 6 and 3 console.log(result); 

Then you ask:

There is a better and fast way to achieve the same result?

A solution involving .map and .reduce could be considered more elegant, like the following:

 var arr = [[[1,1],[2,1],[3,1],[4,2],[5,2],[6,2],[7,3],[8,4]], [[1,1],[2,1],[3,1],[4,3],[5,3],[6,4],[7,4],[8,5],[9,5],[10,5]] ]; var findNumber = 2; var result = arr.map(function(val){ return val[val.reduce(function(acc, curr, index){ return curr[1] <= findNumber? index : acc; }, -1)][0]; }); //gives the expected answers 6 and 3 console.log(result); 

However, in terms of performance, for loops are likely to perform better (run faster) and are easy to comprehend.

In addition, you mention that

the dimension of the arr is not fixed

You would need to post some code examples on how the dimensionality of your data may vary before it would be possible to provide any answer that handles this aspect.

Update

To handle a single array of pairs, you do not need the outer loop or .map() . Putting the solution above into a reusable function:

 function lookupFirstNumberFromSecond(secondNumberToFind, arr){ var j = 0, maxIndex = -1; while(j < arr.length && arr[j][1] <= secondNumberToFind){ maxIndex = j++; } return arr[maxIndex][0]; } //gives the expected answer 6 console.log(lookupFirstNumberFromSecond( 2, [[1,1],[2,1],[3,1],[4,2],[5,2],[6,2],[7,3],[8,4]] )); //gives the expected answer 3 console.log(lookupFirstNumberFromSecond( 2, [[1,1],[2,1],[3,1],[4,3],[5,3],[6,4],[7,4],[8,5],[9,5],[10,5]] )); 

Answer 2

I'm not entirely sure about what you are trying to achieve but I guess Array.reduce is a pretty elegant solution to get a single value out of an array.

eg

var number = 2;
[[1,4],[2,1],[3,1],[4,2],[5,2],[6,2],[7,3],[8,4]]
.reduce(function (a, b) {
   return ((!a || b[0] > a[0]) && b[1] === number) ? b : a;
});

Answer 3

Not entirely sure what you're trying to solve either, but if you're trying to get the max value in a n dimensional array, then the most straightforward method is to solve this standardly in a recursive manner

function recurseMax(arr) {
    if (Number.isInteger(arr)) {
        return arr;
    }
    else {
        answer = 0;
        for (let i = 0; i < arr.length; i++) {
            answer = answer > recurseMax(arr[i]) ? answer : recurseMax(arr[i]);
        }
        return answer;
    }
}
console.log(recurseMax([1,[3, 5], [5, 6, 7, 10], [2, [3, [500]]]])); //Outputs 500

For each element, either is a number or another possible multidimensional element, so we recursively find its max. This avoids potential overhead from a reduce operation (though I'm not experienced enough to speak with confidence whether or not it is completely faster, not really sure of the optimizations V8 can do on reduce or a plain old recursion loop). Either way, the solution is fairly straightforward.

I am answering the question based on the assumption that you mean that the array can have a max dimension of n .