Question

我有一个这样的数组：

var my_array= [
    [2, [[9, 10]]],
    [5, [[10, 11]]],
    [4, [[11, 9]]],
    [1, [[19, 2], [41, 10]]],
    [7, [[17, 3]]],
    [0, [[11, 4], [18, 5]]]
]

my_array中的数组包含另外两个数组（第一个不是必需的，但是查看第二个（myarray[1]：此数组包含不同的x / y坐标[18, 4]）

我想得到另一个看起来像这样的数组（下面的解释）：

var result_array= [
    [ [2, [9, 10]], [5, [10, 11]], [4, [11, 9]], [0, [11, 4]] ],
    [ [1, [19, 2]],  [0, [18, 5]] , [7, [17, 3]] ],    
    [ [1, [41, 10]] ]
]

现在，数组按其x值（[9, 10] - ＆gt; x值：9）进行排序，并按新数组分组。可以说，x值之间的差异可以是+/- 2个索引（x值7,8， 9 ，10,11）可以在一个组中。

我不知道如何编码;这就是我到目前为止所做的：

＆＃13;

var my_array= [
        [2, [[9, 10]]],
        [5, [[10, 11]]],
        [4, [[11, 9]]],
        [1, [[19, 2], [41, 10]]],
        [7, [[17, 3]]],
        [0, [[11, 4], [18, 5]]]
    ]

function sortArray(array) {
  var difference = 2,
    result = '';

  var array_sorted = [];
    array.forEach(function(a) {
     a[1].forEach(function(b) {
       array_sorted.push([b[0],b[1],a[0]]);
    })
  })
  array_sorted = array_sorted.sort(function(a,b) {return a[0]-b[0]});
  
  array_sorted.forEach(function(a) {
    if (a[0] > difference) {
    difference = a[0];
     array_sorted.push(array_group); array_group = [];}
     array_group.push([a]);
  })

  return array_sorted;
}

console.log(sortArray(my_array));

＆＃13;

修改：我忘记提及的一点是，应该分组的坐标y-value difference不应大于1。请看下面的例子：

(x: 3, y:1),(x: 1, y:2),(x: 2, y:3),(x: 4, y:4) - ＆gt; not (x: 4, y:41)

编辑2 ：

var my_array= [
    [2, [[9, 10]]],
    [5, [[10, 11]]],
    [4, [[11, 9]]],
    [1, [[19, 2], [41, 10]]],   
    [7, [[17, 3]]],
    [0, [[11, 4], [18, 5]]]
]

var result_array= [
    [ [2, [9, 10]], [5, [10, 11]], [4, [11, 9]] ], // line 1
    [ [0, [11, 4]] ],                              // line 2 
    [ [1, [19, 2]] ],                              // line 3
    [ [7, [17, 3]] ],                              // line 4 
    [ [0, [18, 5]] ],                              // line 5 
    [ [1, [41, 10]] ]                              // line 6 
]

如果你看一下第1行＆amp;线和＆amp;第2行：x值（第2行：＆＃39; 11＆＃39;＆amp;第1行：＆＃39; 9＆＃39;，＆＃39; 10＆＃39;＆＃39; 9＆＃39;将匹配完全在一起。现在我也想分开y值，就像我上面编辑的例子一样。 - ＆GT;即使是x-values match together，如果y-values match together，也应该将它们分组到新数组中。

Y值匹配意味着，有一个类似行 - ＆gt;
（x：2， y：4 ），（x：1， y：5 ），（x：2， y：6 < / strong>），（x：2， y：7 ）而不是像（x：4， y：42 ）

这样的值
我希望我的编辑让我更容易理解我的想法..

提前致谢，Jonas

Answer 1

修改：格式和代码样式

编辑2：对原始问题编辑的回复

var my_array= [
  [2, [[9, 10]]],
  [5, [[10, 11]]],
  [4, [[11, 9]]],
  [1, [[19, 2], [41, 10]]],   
  [7, [[17, 3]]],
  [0, [[11, 4], [18, 5]]]
]

    var xdifference = 2;
    var ydifference = 1;

  function split(input_array) {
    var splitted = [];

    input_array.forEach(function (item) {
      var coordinates = item[1];
      coordinates.forEach(function (coordinate) {
        splitted.push([item[0], coordinate]);
      });
    });
    return splitted;
  }

  function getXValueOf(item) {
    return item[1][0];
  }

  function getYValueOf(item) {
    return item[1][1];
  }

  function divideIntoHeaps(sorted_array) {
    var heaps = [];
    function findMatchingHeap(item) {
       var matching = heaps.find(function (heap) {
         return heap.every(function (itemOfHeap) {
           var xMatches = Math.abs(getXValueOf(item) - getXValueOf(itemOfHeap)) <= xdifference+1;
           var yMatches = Math.abs(getYValueOf(item) - getYValueOf(itemOfHeap)) <= ydifference+1;
           return xMatches && yMatches;
         });
       });
       return matching;
    }
    function allocate(item) {
      if (heaps.length == 0) {
        heaps.push([item]);
      } else {
        var matchingHeap = findMatchingHeap(item);
        if (matchingHeap !== undefined) {
          matchingHeap.push(item);
        } else {
          heaps.push([item]);
        }
      }
    }
    sorted_array.forEach(allocate);
    return heaps;
  }

  function sortArray(my_array) {
    var splitted = split(my_array);
    var result = divideIntoHeaps(splitted);
    return result;
  }
  
  var result = sortArray(my_array);
  result.forEach( function (row) {
     console.log(JSON.stringify(row));
  });

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

如果我们将输入的部分命名为[[z,[[x,y],[x,y]],...]，则此代码会将其展平为[[x,y,z],...]，按x进行排序，然后将其重新组合成组：

var my_array= [
    [2, [[9, 10]]],
    [5, [[10, 11]]],
    [4, [[11, 9]]],
    [1, [[19, 2], [41, 10]]],
    [7, [[17, 3]]],
    [0, [[11, 4], [18, 5]]]
]

var rearrange = function(arr) {
  // flatten the input structure into [[x,y,z], [x,y,z]]:
  var simpler = [];
  arr.forEach(function(row) {
    row[1].forEach(function(pair) {
      simpler.push([pair[0],pair[1],row[0]]);
    })
  });
  // sort by x:
  simpler = simpler.sort(function(a,b) {
    return a[0]-b[0]
  });
  // console.log(simpler);
  // Now group by x±2, into [ [z,[x,y]],[z,[x,y]] ]
  var output = [];
  var group = [];
  var latestX=simpler[0][0];
  simpler.forEach(function(row) {
    if (row[0] > latestX + 5) {
      // start a new group
      latestX = row[0];
      if (group.length > 0) {
        output.push(group);
        group = [];
      }
    }
    group.push([row[2],[row[0],row[1]]]);  
  });
  output.push(group); // catch the last group
  return output;

}
console.log(rearrange(my_array));

Answer 3

如果值在组的节点的所需范围内，您可以单个点并检查所有组。如果不在任何组中，则生成新组并存储该点。继续，直到没有更多的可用点。

var array = [[2, [[9, 10]]], [5, [[10, 11]]], [4, [[11, 9]]], [1, [[19, 2], [41, 10]]], [7, [[17, 3]]], [0, [[11, 4], [18, 5]]]],
    normalized = array.reduce(function (r, a) {
        return r.concat(a[1].map(function (b) { return [a[0], b]; }));
    }, []),
    grouped = [],
    i, j, k,
    updated;

loop: while (normalized.length) {
    if (!updated) {
        grouped.push([normalized.shift()]);
    }
    updated = false;
    for (i = 0; i < normalized.length; i++) {
        for (j = 0; j < grouped.length; j++) {
            for (k = 0; k < grouped[j].length; k++) {
                if (Math.abs(normalized[i][1][0] - grouped[j][k][1][0]) <= 2 && Math.abs(normalized[i][1][1] - grouped[j][k][1][1]) <= 1) {
                    grouped[j].push(normalized.splice(i, 1)[0]);
                    updated = true;
                    continue loop;
                }
            }
        }
    }
}

console.log(grouped.map(function (a) { return JSON.stringify(a); }));

.as-console-wrapper { max-height: 100% !important; top: 0; }

只有一个版本的旧版本。

你可以采取直接的方式

规范化值，
排序值，
将delta小于或等于2的分组。

var array = [[2, [[9, 10]]], [5, [[10, 11]]], [4, [[11, 9]]], [1, [[19, 2], [41, 10]]], [7, [[17, 3]]], [0, [[11, 4], [18, 5]]]],
    grouped = array
        .reduce(function (r, a) {
            return r.concat(a[1].map(function (b) { return [a[0], b]; }));
        }, [])
        .sort(function (a, b) {
            return a[1][0] - b[1][0];
        })
        .reduce(function (r, a, i, aa) {
            if (aa[i - 1] && a[1][0] - aa[i - 1][1][0] <= 2) {
                r[r.length - 1].push(a);
            } else {
                r.push([a]);
            }
            return r;
        }, []);

console.log(grouped);

.as-console-wrapper { max-height: 100% !important; top: 0; }

重构复杂的嵌套数组

3 个答案: