Javascript根据数组本身找到二维数组中的最大值

Question

我有一个多维数组

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

等等...但是arr的维度不是固定的，是可变的。

我有一个变量告诉我应该把注意力放在哪里

var number = 2;

所以我的目标是查看任何 arr[i] 并根据第二个参数找到最大的第一个参数，我试图更好地解释我自己，在这种特殊情况下，如果数字是 2，我的期望是从 arr ： 对于 arr -> 6 中的第一个数组（因为第二个参数是 1,1,1,2,2,2,3 所以我必须指向最后一个 2 并返回第一个参数） 对于 arr -> 3 中的第二个数组（因为缺少 2 而 1 是最后一个第二个参数）

我知道这有点棘手

我的第一个想法是创建一个 for 循环，在其中删除我的数字上的所有值，然后我可以取最后一个，但我认为我过于复杂了。

有没有更好更快的方法来达到同样的效果？

J

Answer 1

您呈现数字对的列表（数组），其中数字对按升序排序，首先按第二个数字，然后按第一个。

您似乎要求的是：给定一个要在第二个数字中搜索的数字，例如number = 2，找到第二个数小于等于这个数的最后一个对，返回这个对中对应的第一个数。

您声明可以使用for 循环来解决问题。一个简单的方法可能类似于以下 sn-p：

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

然后你问：

有没有更好更快的方法来达到同样的效果？

涉及.map 和.reduce 的解决方案可以被认为更优雅，如下所示：

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

但是，就性能而言，for 循环可能会执行得更好（运行得更快）并且易于理解。

另外，你提到了

arr的维度不固定

您需要发布一些代码示例，说明您的数据维度可能如何变化，然后才能提供任何处理此方面的答案。

更新

要处理单个对数组，您不需要外部循环或.map()。将上面的解决方案放入一个可重用的函数中：

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

我不完全确定您要达到的目标，但我猜Array.reduce 是一个非常优雅的解决方案，可以从数组中获取单个值。

例如

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

也不完全确定您要解决什么问题，但如果您要在 n 维数组中获取最大值，那么最直接的方法是以递归方式标准地解决此问题

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

对于每个元素，要么是一个数字，要么是另一个可能的多维元素，所以我们递归地找到它的最大值。这避免了 reduce 操作的潜在开销（尽管我没有足够的经验来自信地说它是否完全更快，不确定 V8 可以在 reduce 或普通的旧递归循环上做的优化） .无论哪种方式，解决方案都相当简单。

我根据您的意思是数组的最大维度为n 的假设来回答这个问题。