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循环，我删除了所有数值，然后我可以选择最后一个，但我认为我过于复杂了。

有一种更好，更快的方法可以达到相同的效果吗？

Ĵ

Answer 1

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

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

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

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是一个非常优雅的解决方案，可以从数组中获取单个值。

<强> e.g。

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。

Javascript根据数组本身在2d数组中找到最高值

3 个答案:

更新