logo标签列表

重构复杂嵌套数组

javascriptjqueryarraysmultidimensional-array
3

我有一个这样的数组：

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] --> x值: 9）并分组到新数组中。x值之间的差可以是，比如说，+/-2个索引（x值7,8,9,10,11）可以在一组中。

我不知道如何编写这个代码；这是我目前为止的内容：

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

编辑: 我忘记提到一点，应该分组的坐标的y值差不应超过1。请看下面的例子:

(x: 3, y:1),(x: 1, y:2),(x: 2, y:3),(x: 4, y:4) --> 不是 (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 
]

如果您看一下第一行和第二行：x值（第二行：'11'和第一行：'9'、'10'、'9'）完全匹配。现在我也想像上面编辑的示例一样分离y值。 --> 即使x值匹配，如果y值匹配，它们也应该被分成新的数组。
Y值匹配意味着存在类似于一行的内容 --> (x: 2, y:4),(x: 1, y:5), (x: 2, y:6), (x: 2, y:7)，而不是像（x: 4, y:42）这样的值。
我希望我的编辑能让人更容易理解我的想法...
提前感谢，乔纳斯
真的不知道如何回答这样的评论 @mplungjan - Jonas0000
你写了一段代码片段。这个片段立即显示了一个错误，错误在于 return b[1][0] - b[1][0]，在继续之前你需要解决它，我想。 - mplungjan
@DanielBeck 每次从第一个开始 [2, [[9, 10]]]（第一个数组 --> xValue: 9） - Jonas0000
从第一个开始，每次都是如此。这就是我的观点；举个例子，如果你的数据包含了值为1…10的x值，如果你从第一个开始，那么(1,2,3)会被归为一组，作为1±2；然后是(4,5,6)；(7,8,9)；(10)。但是，如果你想要最少的分组数，你会希望是(1..5)，(6..10)--这样做会更加复杂，因为它需要查看整个x值集来确定最佳的分组方式，而不仅仅是从第一个值开始... - Daniel Beck
你完全是对的，但第一种（更简单）的解决方案也可以。只需要检查第一个元素+-2个索引就可以了。@DanielBeck - Jonas0000
显示剩余4条评论
3个回答
0

编辑：格式和代码风格

编辑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; }

1
好的，我已经试图寻找您的解决方案很长时间了，现在我认为我刚刚理解了您的想法。看起来很好，非常感谢 <3 - Jonas0000
我已经更新了代码，但是得到了一个结果，以1和7开头的项都落在同一个堆中。如果它们的x差为2，y为1，这样是否可以？ - mpasko256
0
如果我们将您的输入部分命名为[[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));

你的解决方案看起来非常好。非常感谢，Daniel。如果你愿意再帮我一次，看看我上面的编辑。提前致谢，问候。 - Jonas0000
这是一个相当重大的问题变化。 - Daniel Beck
你说得完全正确，丹尼尔。没关系，如果你不想了解，我稍后自己会看一下。不过，非常感谢！ - Jonas0000
0
你可以选择一个单一的点，并检查所有组是否该节点的值在所需范围内。如果不在任何组中，则生成一个新组并存储该点。继续进行，直到没有更多的点可用。 

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

仅针对一维的旧版本。

您可以采用直接的方法：

  • 归一化数值，
  • 排序数值，
  • 在增量小于或等于二的情况下进行分组。

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

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接