Javascript 如果所有列和行的值相等，则从二维矩阵中删除它们 我的矩阵/2d数组如下所示*|*

我想得到这个结果

       |                                |
       Y                                Y

[                                 
   [0,0,0,0],                     [
   [0,1,0,2],        --->           [1,0,2],
   [0,2,3,0],                       [2,3,0],
   [0,5,0,0]                        [5,0,0]
]                                 [

如果所有行/列的值都相等，我想删除它们

0 1 2 3 4
1 A A A A      --> remove col 1
2 B B B B
3 B X B C
4 A B O B



0 1 2 3 4
1 A A C A      
2 B B C B
3 B X C C
4 A B C B
      |
      |
      Y
  remove row 3

我的想法是使用下面的函数，但我的代码似乎不起作用

检查X方向的“相等”没有问题，但我不知道Y方向有什么问题。很明显，它没那么好用：p

我的职能：

var myarray=[
[0,0,0,0],
[1,0,0,0],
[1,0,0,0],
[1,0,0,0]
]
删除相等的行（myarray）
函数remove_equal_行（数组）{
/*
x方向-->（工作）
*/
var statusX=真；
对于（变量i=0；i（不工作）
*/
var statusY=true；
对于（var i=0；i而言，从技术上讲，您再次检查了第二对循环中的行，

var statusY=true;
for (var i=0;i<array[0].length;i++) {
  for (var j = 1; j < array.length; j++) {
    if (array[j][i] !== array[0][i]) {
      statusY=false;break;
    } else statusY=true
  }
  console.log('remove row "'+i+'": ' + statusY)
}

var statusY=true；
对于（var i=0；i独立删除行和列：

删除列和行，同时使用原始未更改的矩阵作为参考：


函数删除（矩阵）{
让newMatrix=matrix.filter（row=>row.some（e=>e！=row[0]）//过滤具有不同值的行
.map（row=>row.slice（0））；//将它们复制到newMatrix中（这样原始矩阵不会受到更改它们（行）的影响）
if（newMatrix.length==0）返回newMatrix；//如果newMatrix结果是无行的（那么只需重新运行它而不尝试清理列）
对于（var i=newMatrix[0]。长度为-1；i>=0；i--）{//对于每列（向后循环，以便删除列不会影响索引i）
var first=矩阵[0][i]；//获取第一行第i列的值
if（matrix.every（row=>row[i]==first））{//如果所有行对于第i列具有与first相同的值
newMatrix.forEach（row=>row.splice（i，1））；//然后从每行中删除第i项（列）
}
}
返回新矩阵；
}
var结果=删除([
[0,0,0,0],
[1,0,0,0],
[1,0,5,0],
[1,0,0,0]
]);
console.log（result.join（“\n”）；
您可以通过使用每个数组并将其转换为a来删除行。如果集合的大小为1，则应删除该数组

要筛选列，从头开始重建网格更容易。使用迭代第一行。使用初始化新网格。对于每一列，从原始列创建一个集合（在筛选行之前），如果集合的大小大于0，请使用将其项推送到新网格


const myarray=[
[0,0,0,0],
[1,0,0,0],
[1,0,0,0],
[1,0,0,0]
];
const filteredRows=myarray.filter（（arr）=>new Set（arr）.size！==1）；//如果行集合仅包含1项，则应将其删除
const filteredColumns=（filteredRows[0]| |[]）。reduce（（r，|，i）=>{//迭代第一行
const keep=new Set（myarray.map（（arr）=>arr[i]）。size>1；//如果原始网格中的列集合包含多个项，则应将其保留
keep&&filteredRows.forEach（（arr，j）=>r[j].push（arr[i]）；//如果我们保留它，则将列放入网格
返回r；
}，Array.from（{length:filteredRows.length}，（）=>[]）；//使用空网格初始化
console.log（filteredColumns）；
尝试以下操作：（第一行0将被删除，然后列0和列2将被删除）

var myarray=[
[0,0,0,0],
[1,0,2,0],
[1,1,2,1],
[1,0,2,0]
]
删除相等的行（myarray）
函数remove_equal_行（myArray）{
/*
x方向-->（工作）
*/
var resultX=[]；
用于（变量i=0；i（正在工作）
*/
变量状态，结果=[]；
对于（var i=0；i我递归地实现了这一点，它通过唯一化器反复运行结果数组，直到没有修改为止

使X方向的行不同于列更简单，因此可以通过旋转矩阵->不同的X方向->向后旋转来处理不同的列


var masterArr=[
[0,0,0,0],
[1,0,0,0],
[1,0,3,0],
[1,0,0,4]
];
函数uniqueColRow（arr）{
如果（arr.length==0 | | arr[0]。length==0）{
返回arr；
}
var distinctRows=arr.filter（（x）=>{return x.filter（unique）.length>1；}）；
var flip=旋转耳环（distinctRows）；
var distinctCols=flip.filter（（x）=>{return x.filter（unique）.length>1；}）；
var resultArr=旋转耳（distinctCols）；
如果（arr.length！==resultArr.length | | arr[0]。length！==resultArr[0]。length）{
log（'再次运行时使用：'）；
console.log（resultar）；
返回uniqueColRow（resultArr）；
}否则{
返回结果器；
}
}
console.log（'Original:'）；
控制台日志（masterArr）；
console.log（'\n'）；
var结果=uniqueColRow（masterArr）；
console.log（'\n最终：'）
控制台日志（结果）；
功能旋转耳环（arr）{
返回arr[0].map（（col，i）=>arr.map（row=>row[i]）；
}
函数唯一（项，i，自）{
返回自索引（项目）==i；
}
首先删除谁：一行还是一列？（因为删除一列可能会产生一个需要删除一行的新矩阵，反之亦然）。或者删除列和行应该是独立的（使用原始矩阵作为参考）？非常感谢您的回答。我将在稍后研究您的代码：）谢谢你的解决方案。看起来非常好！绝对正确。谢谢D:
var myarray=[
  [0,0,0,0],
  [1,0,2,0],
  [1,1,2,1],
  [1,0,2,0]
]

remove_equal_rows(myarray)
function remove_equal_rows(myArray) {
  /*
    x direction --> (working)
  */

  var resultX = [];

  for (var i=0; i<myArray.length;i++) {
    statusX = true;
    for (var j = 1; j < myArray[i].length; j++) {
      if (myArray[i][j] !== myArray[i][0]) {
        statusX=false;break;
      }
    }
    if (statusX) { resultX.push(i); }
  }
  console.log('rows indexes to remove : ', resultX);
  resultX.map(function(item) { myArray.splice(item,1); });

  console.log('-------', myArray);
  /*
    y direction --> (now working)            
  */
  var statusY, resultY = [];
  for (var i=0;i<myArray.length;i++) {
    statusY = true;
    for (var j = 1; j < myArray.length; j++) {
      console.log(j, i, myArray[j][i]);
      if (myArray[j][i] !== myArray[0][i]) {
        statusY=false;break;
      }
    }
    if (statusY) {resultY.push(i);}
  }
  console.log('cols indexes to remove : ', resultY);
  resultY.map(function(item) { myArray.splice(item,1); });

  console.log('-------', myArray);
}