Question

我有一个像这样的数组

var my_array = [
  [3,9],
  [1,5],
  [7,2],
  [5,4]
 ]

正如您所看到的，my_array是一个多维数组，在这种情况下包含4个不同的数组。

所有数组都是x / y坐标（[3,9] ---> X：3，Y：9），我想用...移动数组的数组。 p>

最大的X值，
最大的Y值，
最小的X值，
最小Y值

...对象这样的对象：

var my_object = {
  "minX": [1,5],
  "maxX": [7,2],
  "minY": [7,2],
  "maxY": [3,9]
}

我创建的函数你可以在下面找到，但我的函数只是从上面返回列出的值而不是返回完整的数组。所以我目前的（错误的）结果如下：

var wrong_object = {
  "minX": 1, // missing 5
  "maxX": 7, // missing 2
  "minY": 2, // missing 7
  "maxY": 9  // missing 3
}

var my_array = [
  [3, 9],
  [1, 5],
  [7, 2],
  [5, 4]
]

var extreme_result = {}
extreme_result.minX = Math.min.apply(Math, my_array.map(function(i) {
  return i[0]
}));
extreme_result.maxX = Math.max.apply(Math, my_array.map(function(i) {
  return i[0]
}));
extreme_result.minY = Math.min.apply(Math, my_array.map(function(i) {
  return i[1]
}));
extreme_result.maxY = Math.max.apply(Math, my_array.map(function(i) {
  return i[1]
}));

console.log(extreme_result)

我希望有人可以帮我解决这个问题。

提前致谢，Greetings Pete

Answer 1

这会对数组进行排序，并抓取最小和最大对象的第一个和最后一个元素。

＆＃13;

var my_array = [
  [3, 9],
  [1, 5],
  [7, 2],
  [5, 4]
];

my_array.sort(function(a, b){ return a[0] - b[0]; });
var minX = my_array[0];
var maxX = my_array[my_array.length - 1];
my_array.sort(function(a, b){ return a[1] - b[1]; });
var minY = my_array[0];
var maxY = my_array[my_array.length - 1];

console.log(JSON.stringify({
  minX: minX,
  maxX: maxX,
  minY: minY,
  maxY: maxY
}));

＆＃13;

Answer 2

function findExtremes( array ){
  let maxX = array[0],
       maxY = array[0],
       minX = array[0],
       minY = array[0];

  for(const [x,y] of array){
    if(x < minX[0]) minX = [x,y];
    if(x > maxX[0]) maxX = [x,y];

    if(y > minY[1]) minY = [x,y];
    if(y < maxY[1]) maxY = [x,y];
  }

  return {maxX, maxY, minX, minY};
}

这是O（n）......

Answer 3

如果你不介意使用es6，你可以这样做：

＆＃13;

const my_array = [
  [3,9],
  [1,5],
  [7,2],
  [5,4],
];

const results = {
  xMax: Math.max(...my_array.map(e => e[0])),
  xMin: Math.min(...my_array.map(e => e[0])),
  yMax: Math.max(...my_array.map(e => e[1])),
  yMin: Math.min(...my_array.map(e => e[1]))
}

const points = {
  xMax: my_array.filter(e => e[0] === results.xMax),
  xMin: my_array.filter(e => e[0] === results.xMin),
  yMax: my_array.filter(e => e[1] === results.yMax),
  yMin: my_array.filter(e => e[1] === results.yMin)
}

console.log(points);

＆＃13;

编辑：

抱歉，我误解了这个问题。编辑上面的答案。

Answer 4

我会通过比较forEach而不是映射，排序或其他来实现这一点。

let my_array = [
  [3, 9],
  [1, 5],
  [7, 2],
  [5, 4]
]

let extreme_result = {
  minX: my_array[0],
  minY: my_array[0],
  maxX: my_array[0],
  maxY: my_array[0]
};

my_array.forEach( (el) => {

  if ( extreme_result.minX[0] > el[0] ) {
    extreme_result.minX = el;
  } else if ( extreme_result.maxX[0] < el[0] ) {
    extreme_result.maxX = el;
  }

  if ( extreme_result.minY[1] > el[1] ) {
    extreme_result.minY = el;
  } else if ( extreme_result.maxY[1] < el[1] ) {
    extreme_result.maxY = el;
  }

});

console.info(extreme_result);

Answer 5

var my_array = [
    [3, 9],
    [1, 5],
    [7, 2],
    [5, 4]
];
let extreme_result={};
extreme_result.MinX=my_array.reduce(function(a,b){
    if(a[0]<b[0]){
        return a;
    }
    else{
        return b;
    }
});
extreme_result.MinY=my_array.reduce(function(a,b){
    if(a[1]<b[1]){
        return a;
    }
    else{
        return b;
    }
});
extreme_result.MaxX=my_array.reduce(function(a,b){
    if(a[0]>b[0]){
        return a;
    }
    else{
        return b;
    }
});
extreme_result.MaxY=my_array.reduce(function(a,b){
    if(a[1]>b[1]){
        return a;
    }
    else{
        return b;
    }
});
console.log(extreme_result);

从多维数组中获取minX，maxX，minY，maxY

5 个答案: