Question

在一个函数中，我输入两个2D阵列（超过50x50），两者都具有相同的Nr。列但不同的Nr。的行。基本上我需要删除包含0到2范围内的数字的公共列

示例：

A: 3 0 0 0 0 1 0
   5 0 0 6 0 0 2
   2 0 0 7 1 0 0

B: 2 3 0 1 0 0 1
   4 9 0 2 0 0 0

在这种情况下，我必须删除第3列，第6列和第7列（到A和B），因为第3列只有0，第6列只有0和1，而最后一列全部是Nr。从0到2。

我可以使用像 LinearAlgebra.deleteColumns（A，2,5,6）; 和 LinearAlgebra.deleteColumns（B，2,5,6）; 这样的函数但由于我的输入数组很大，我必须进行列解析，比较两个数组。

任何想法接近这个？这是使用3 for for循环（java）的原始想法

for(int col=0; col < A[0].length; col++){   // step through each column
    int cnt = 0;

    for(int row = 0; row < B.length ; row ++){ 
        if(!(B[col][row].equals(0 | 1 | 2))) {
            cnt++;       
        }
    }

    if(cnt == 0) {
        // store number of column -> use later on LinearAlgebra.deleteColumns
    }

    for(int row = 0; row < A.length  ; row++){        
        if(!(A[col][row].equals(0 | 1 | 2)))
        cnt++;             
    }
    if(cnt == 0){
        // check aswell all values of B otherwise iterate next column
    }  
}

Answer 1

制作一个boolean标记，循环显示列并确定要删除的列。

查找可删除列的示例：

boolean deleteFlag;
for ( int i = 0; i < columnAmount; i++ ) {
    deleteFlag = true;
    for (int j = 0; j < firstTableRowAmount; j++ ) {
        if (A[j][i] != 0) {
           deleteFlag = false;
           break;
        }
    }
    if(!deleteFlag) {
        continue;
    }
    for (int j = 0; j < secondTableRowAmount; j++ ) {
        if (B[j][i] != 0) {
           deleteFlag = false;
           break;
        }
    }
    if(deleteFlag) {
        callDeleteColumnFunction(i);
    }
}

和callDeleteColumnFunction(i)是一个删除两个2D数组的i-th列的函数。

Answer 2

boolean result[] = new boolean[<num of columns>];
for (int i = 0; i < result.length; ++i)
    result[i] = true;

for (int row = 0; row < arrayA.length; ++row) {
   for (int col = 0; col < arrayA[row].length; ++col)
       result[col] &= arrayA[row][col] == 0; 
}

for (int row = 0; row < arrayB.length; ++row) {
       for (int col = 0; col < arrayB[row].length; ++col)
       result[col] &= arrayB[row][col] == 0; 
}

for (int i = 0; i < 6; ++i) 
    System.out.println(result[i]);

现在result数组中的每个单元格（列）都将指示哪个列包含两个数组的零。

* 注意：* 如你所说，这两个数组具有相同的列数

由于评论而编辑：

如果要删除其值在某个范围内的列，请使用以下条件：

 result[col] &= arrayA[row][col] >= minRange && arrayA[row][col] <= maxRange;

对于专属范围，只需删除=符号

即可

并对第二个数组执行相同的操作

Answer 3

首先，你可能会混淆你的col和row顺序，因为你使用A[0].length获得了行计数，但是你在B[col][row]中使用它，但是对于这一部分，我让你详细了解。

无论如何，如果我理解你的问题，你正在寻找只包含0的列。

为此，您应首先在true时初始化bool，当值不为0时，您将其置为false。使用与第二个bool的第二个相同的过程，你最终比较两个bool，知道你是否必须删除列;）

Answer 4

辅助功能：

private boolean isColumnDeletable(final int column, final int[][] array) {
    for (int row = 0; row < array.length; row++) {
        if (array[row][column] != 0)
            return false;
    }

    return true;
}

使用示例：

int[][] values1 = new int[][] {{1, 1, 1, 0, 1}, {2, 2, 2, 0, 2}, {3, 3, 3, 0, 3}};
int[][] values2 = new int[][] {{4, 4, 4, 0, 4}, {5, 5, 5, 0, 5}};


for (int column = 0; column < values1[0].length; column++) {
    System.out.printf("Checking column %d: ", column + 1);

    if (isColumnDeletable(column, values1) && isColumnDeletable(column, values2))
        System.out.printf("Deletable!\n");
    else
        System.out.printf("Not deletable!\n");
}

输出：

Checking column 1: Not deletable!
Checking column 2: Not deletable!
Checking column 3: Not deletable!
Checking column 4: Deletable!
Checking column 5: Not deletable!

在拆分的阵列上删除0s的列

4 个答案: