Question

我试图在java中编写一个代码，看看行和列中的所有元素是否相同并打印出它的索引。

例如，如果我有二维数组

int[][] array_1 = { {1}, 
                    {1} };
for(int row=0; row<array.length-1; row++){
        for (int col=0; col<array[0].length-1; col++){
              if(array[row][col]==array[row+1][col]&&
                 array[row][col]==array[row][col+1]&&
                 array[row][col]==array_1[0][0]) {
                  System.out.print(row);
                  System.out.println(col);      
                 }
        }
}

我想要打印出2,0这意味着在第2行中所有元素都是相同的，在第0列中所有元素也是相同的并且它们彼此相等。

我试图用语句

来做

{{1}}

但它不起作用，因为它没有检查所有的行和列，它停在中间的某个地方，我不知道发生了什么。

你有什么建议吗？

Answer 1

您可以通过分离方法来完成此操作首先，你可以编写一个转置方法

public static int[][] transpose(int[][] A) {
        int m = A.length;
        int n = A[0].length;
        int[][] C = new int[n][m];
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                C[j][i] = A[i][j];
        return C;
    }

然后，您可以编写此方法来检查行和列。如果行的元素或列的元素不同，则此方法返回false.Else返回true。

public static boolean rowColEquals(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int x = array[0];
            if (x != array[i])
                return false;
        }
        return true;
    }

最后，您可以编写此方法来寻找答案。

public static void findEquals(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            if (rowColEquals(array[i])) {
                System.out.println("All " + array[i][0] + " is equal on row "
                        + i);
            }
        }
        array = transpose(array);
        for (int i = 0; i < array.length; i++) {
            if (rowColEquals(array[i])) {
                System.out.println("All " + array[i][0] + " is equal on colomn "
                        + i);
            }
        }
    }

主要方法如下

public static void main(String[] args) {
int[][] y = { { 1, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0 }, { 1, 1, 1, 1, 1 } };
        findEquals(y);
    }

，输出将跟随。

All 1 is equal on row 2
All 1 is equal on colomn 0

Answer 2

一种方法是：

找到所有相等的行。将他们的索引放入某种集合（例如，集合或列表）。
找到所有相等的列。将他们的指数放入另一个集合。
对于每个相等的行，对于每个相等的列，请打印row, column。

结果包括与等列集合中的一个成员配对的等行集合的一个成员的所有组合。如果没有，则行或列不能相等。

Answer 3

我认为你在这里要做的是获取具有相同元素的所有行和列，然后返回行和列元素相等的组合。

因此，例如，如果您的数组是 -

{ 1, 0, 0, 1, 0}
{ 1, 0, 0, 1, 0}
{ 1, 1, 1, 1, 1}

然后它应该返回（2,0）和（2,3）。

现在有一点需要注意的是，只有一种类型的这种交叉可能，即如果有一列所有1和一列所有2，那么就不可能得到一行全部1或全部2。

因此，您应检查每列的一致性（所有相同的元素），并检查是否有多于一种列的所有元素都相同（即具有不同数值的一致列）。

如果是，那么你将得不到答案，如果不是，那么你应该找到一致的（相同元素）行，其值等于列中的元素。

Answer 4

这里的逻辑有多个缺陷。最明显的一个是

`if(array[row][col]==array[row+1][col]&&
   array[row][col]==array[row][col+1]&&
   array[row][col]==array_1[0][0]) {
   **System.out.print(row);
   System.out.println(col);**                    
 }

`

您甚至不等待检查整行与列。另外，你比较

array[row][col]==array_1**[0][0]**。

安迪的建议是暴力，但应该让你开始。您可以优化算法。

Answer 5

我就是这样做的：

public void findIntersection ( Object[][] a ) {

    Object knownIntersectionValue = null;
    rowLoop: for (int i = 0; i < a.length; i++ ) {
        final Object candidateValue = a[i][0];
        if ( knownIntersectionValue != null && !candidateValue.equals(knownIntersectionValue) ) {
            // This cannot be an intersection, because all existing intersections must share the same value.
            continue rowLoop;
        }
        ArrayList<Integer> candidateColumns = new ArrayList<Integer>();
        // Loop through columns in the current row
        columnLoop: for ( int j = 0; j < a[0].length; j++ ) {
            if ( ! a[i][j].equals(candidateValue ) ) {
                // We've hit a column with a different value -- no intersections on this row!
                continue rowLoop;
            }
            // The column has the same value as the 1st column, so the current element MAY be an intersection.
            // Check all the rows for the column
            for ( int k = 0; k < a.length; k++ ) {
                if ( ! a[k][j].equals(candidateValue )) {
                    // No, the row, column is not an intersection
                    continue columnLoop;
                }
            }
            // If we get here, then column J is a potential intersection
            // We won't know until we finish checking the row
            candidateColumns.add(j);
        }
        // Print the intersections we've found for the current row
        for ( Integer j : candidateColumns ) {
            System.out.println("Intersection at " + i + ", " + j);
            if ( knownIntersectionValue == null ) {
                knownIntersectionValue = a[i][j];
            }

        }
    }
}

Answer 6

我得到了如何实现它，我认为它比在这里发布的更容易。

我不想发布代码，但算法是让一个for循环通过列并找到一个等于1的那个。

之后有另一个for循环遍历行并找到它等于1的位置。

记住索引并打印出来。

如果行和列中的所有元素都相同，如何检入2d数组？

6 个答案: