java - 查找相同值的4个连续数字-垂直和对角线

Question

我必须找出矩阵（8x7）中有多少连续的垂直和对角线具有4个连续的相同值的数字。如果我是对的，则有2条垂直线和4条对角线。

2 1 1 6 1 0 0

2 1 1 7 6 0 1

1 1 7 1 6 1 1

9 7 6 0 1 1 6

7 9 1 1 6 9 0

7 5 9 2 2 2 0

7 5 9 9 9 9 0

7 1 1 1 1 0 0 0

但是当我运行它时：

垂直线数：3

有人知道如何解决此问题吗？我早些时候问过类似的问题，但是使用水平线，我应用了那里给出的内容，但是没有用。

我也很困惑如何找到对角线，有人知道怎么做吗？

public class Q5_Numbers{
    public static void main(String[] args){

        int[][] matrix = {
            {2, 1, 1, 6, 1, 0, 0},
            {2, 1, 1, 7, 6, 0, 1},
            {1, 1, 7, 1, 6, 1, 1},
            {9, 7, 6, 0, 1, 1, 6},
            {7, 9, 1, 1, 6, 9, 0},
            {7, 5, 9, 2, 2, 2, 0},
            {7, 5, 9, 9, 9, 9, 0},
            {7, 1, 1, 1, 1, 0, 0}
        }; 

        // # of vertical Lines = 2 
        System.out.printf("# of vertical lines: %d\n", findVertical(matrix));

        // # of diagonal lines = 4;
        System.out.printf("# of diagonal lines: %d\n", findDiagonal(matrix));

    }

    public static int findVertical(int[][] values){
        int countV = 0;
        int found = 0;

        for(int j = 0; j < values[0].length; j++){ 
            int current = values[0][j];
            for(int i = 0; i < values.length; i++){
                if(values[i][j] == current){
                    found++;
                    if(found == 4){
                        countV++;
                        found = 0;
                    }
                }
            }
        }
        return countV;
    }

    public static int findDiagonal(int[][] values){
        ...
    }
}

Answer 1

介绍

为了让以后这个问题的读者受益，我将展示如何制定解决方案。

从问题：


我必须找出多少条垂直线和对角线连续4条
矩阵中相同值的数字（8x7）。


用更正式的方式说明这一点。


找到具有相同值的四个连续数字的垂直线的数量。
查找具有四个连续的相同值的对角线的数量。


首先，我们有一个二维数组。每行有7个值。每列有8个值。这意味着行索引从0到6，列索引从0到7。Java具有从零开始的索引。

    int[][] matrix = {
        {2, 1, 1, 6, 1, 0, 0},
        {2, 1, 1, 7, 6, 0, 1},
        {1, 1, 7, 1, 6, 1, 1},
        {9, 7, 6, 0, 1, 1, 6},
        {7, 9, 1, 1, 6, 9, 0},
        {7, 5, 9, 2, 2, 2, 0},
        {7, 5, 9, 9, 9, 9, 0},
        {7, 1, 1, 1, 1, 0, 0}
    }; 

垂直线

那么，我们如何检查第一列中的前4个数字？记住，这是铅笔和纸的思维。

前四个数字位于索引[0，0]，[1，0]，[2，0]和[3，0]。我们在这里看到图案了吗？

好吧，第二个索引（行索引）保持为零。第一个索引（列索引）对于矩阵中的每一列递增一个。

那么您将如何在代码中执行此操作？

我们的第一次尝试可能看起来像这样。

int temp = matrix[0, 0];
if (matrix[1, 0] == temp && matrix[2, 0] == temp
        && matrix[3, 0] == temp) {
    return true;
} else {
    return false;
}

记得。我们并不是在尝试编写高效的代码。我们正在尝试编写代码，以帮助我们理解问题并起作用。

因此，让我们来看一下刚刚编写的代码中发生的情况。

int temp = matrix[0, 0];
int temp = 2;

matrix[1, 0] = 2是吗？

是的。

matrix[2, 0]怎么样？等于2吗？

不， matrix[2, 0]等于1。哦，发生了 else条件，我们编写的代码返回了 false。

现在，我们可以复制这段代码，并在每次复制时更改列和行下标。但是有更好的方法。让我们概括一下代码。

这就是我们的开始。

int temp = matrix[0, 0];
if (matrix[1, 0] == temp && matrix[2, 0] == temp
        && matrix[3, 0]) {
    return true;
} else {
    return false;
}

那么，我们如何对此进行概括？

我们首先将列设为变量。

int column = 0;
int temp = matrix[column, 0];
if (matrix[column + 1, 0] == temp && matrix[column + 2, 0] == temp
        && matrix[column + 3, 0]) {
    return true;
} else {
    return false;
}

我们采取一些小步骤来概括我们的代码。现在，在我们的研究中，什么使我们可以循环增加变量？

为什么要使用 for循环！

因此，我们可以这样编写代码。

int column = 0;
int temp = matrix[column, 0];
for (int i = column + 1; i < column + 4; i++) {
    if (temp != matrix[i, 0]) {
        return false;
    }
}
return true;

因此，让我们分解 for循环。记住，我们的代码看起来像这样。

int column = 0;
int temp = matrix[column, 0];
if (matrix[column + 1, 0] == temp && matrix[column + 2, 0] == temp
        && matrix[column + 3, 0} == temp) {
    return true;
} else {
    return false;
}

因此，您可以看到我们直接使用了 column + 1语句中的 if。

column + 4有点棘手。在 if语句中，我们仅上至 column + 3。那为什么 column + 4呢？

这是真的。我们本可以这样编写 for循环。

for (int i = column + 1; i <= column + 3; i++) {

没关系。在Java中，约定是使用小于号，而不是小于或等于号来结束 for循环。

但是还有另一个原因我们以这种方式编写 for循环。

for (int i = column + 1; i < column + 4; i++) {

4代表我们要检查的行数。换句话说，我们正在寻找相等的4个连续数字。

现在，这部分代码。

    if (temp != matrix[i, 0]) {
        return false;
    }

需要一点解释。

我们正在寻找具有相同值的4个连续数字。这意味着任何不相同的值都会使命题错误。因此，第一次后续矩阵值不等于第一个矩阵值时，我们可以返回 false。

顺便说一下，这正是if语句“在幕后”工作的方式。

if (matrix[column + 1, 0] == temp && matrix[column + 2, 0] == temp
        && matrix[column + 3, 0} == temp) {

那么，如何才能进一步推广此代码？

为什么，我们可以将其放入方法中！

private boolean checkVerticalLine(int column, int row,
        int depth) {
    int temp = matrix[column, row];
    for (int i = column + 1; i < column + depth; i++) {
        if (temp != matrix[i, row]) {
            return false;
        }
    }
    return true;
}

我在这里所做的主要更改是将列和行作为参数传递，并传递我们要检查的值的数量（ depth）。这从我们的代码中删除了“幻数” 4。

我已经累了，而且还没有写书，所以这是计算所有具有四个连续数字的垂直线的代码。

int depth = 4;
int count = 0;
for (int column = 0; column <= (8 - depth); column++) {
    for (int row = 0; row < 7; row++) {
        if (checkVerticalLine(column, row, depth)) {
            count++;
        }
     }
 }

我们不必遍历所有起始列。如果这样做，我们将得到索引超出范围的错误。我们只需要检查起始列0到4。

在这种情况下，我在列 for语句中使用了小于或等号，因为它使数学更容易。

对角线

您使用相同的推理来求解对角线。

让我们再次以matrix [0，0]的值作为起点，并编写一些铅笔和纸质代码。

int temp = matrix[0, 0];
if (matrix[1, 1] == temp && matrix[2, 2] == temp
        && matrix[3, 3] == temp) {
    return true;
} else {
    return false;
}

唯一的区别是我们将列和行加1。跳过很多步骤，我们得到以下方法。

private boolean checkDiagonalLine1(int column, int row,
        int depth) {
    int temp = matrix[column, row++];
    for (int i = column + 1; i < column + depth; i++) {
        if (temp != matrix[i, row++]) {
            return false;
        }
    }
    return true;
}

与垂直线方法的唯一区别是方法的名称，并且我们增加了 row值和 column值。由于Java是传递引用，因此我们不会在调用方法中更改 row的值。

调用代码将如下所示。

int depth = 4;
int count = 0;
for (int column = 0; column <= (8 - depth); column++) {
    for (int row = 0; row <= (7 - depth); row++) {
        if (checkDiagonalLine1(column, row, depth)) {
            count++;
        }
     }
 }

我们必须同时调整起始列和起始行的值，以免出现索引超出范围的错误。

我们仍然必须检查相反的对角线。同样，编写一些铅笔和纸质代码。

int temp = matrix[0, 0];
if (matrix[1, -1] == temp && matrix[2, -2] == temp
        && matrix[3, -3] == temp) {
    return true;
} else {
    return false;
}

等待！我们不能有下标！

让我们再试一次。这次，我们将以零行结束。

int temp = matrix[0, 3];
if (matrix[1, 2] == temp && matrix[2, 1] == temp
        && matrix[3, 0] == temp) {
    return true;
} else {
    return false;
}

再次概括并跳过许多步骤，我们最终得到以下方法。

private boolean checkDiagonalLine2(int column, int row,
        int depth) {
    int temp = matrix[column, row--];
    for (int i = column + 1; i < column + depth; i++) {
        if (temp != matrix[i, row--]) {
            return false;
        }
    }
    return true;
}

调用代码将如下所示。

int depth = 4;
int count = 0;
for (int column = (depth - 1); column < 8; column++) {
    for (int row = 0; row <= (7 - depth); row++) {
        if (checkDiagonalLine2(column, row, depth)) {
            count++;
        }
     }
 }

在此检查中，起始列从3到7。起始行从0到4。

我希望这种解释对某人有帮助。记住，我们不仅要编写代码。我们必须找出解决问题的方法。然后我们开始编写代码。