Question

我正在做的是创建一个具有一定数量的行和列的矩阵，并且我用0到9范围内的随机整数填充该表。我现在要做的是确定是否有连续的偶数在表中彼此重复四次的整数。例如，像这样：

在该表中，两个从第一个点对角地连续出现。它也可以是这样的：

在此表中，五个从第二个位置垂直向下显示。

我创建了二维数组，如下所示：

public static void main(String[] args) {
    int[][] randomTable = new int[5][5];
    for (int row = 0; row < randomTable.length; row++) {
        for (int column = 0; column < randomTable[row].length; column++) {
            randomTable[row][column] = (int)(Math.random() * 10 + 0);
            System.out.print(randomTable[row][column] + " ");
        }
        System.out.println();
    }       
}

在测试数组时，如果数组包含上面详述的那四个连续的偶数整数，我需要它返回true。我知道我需要创建一个循环，但是我该怎么做呢？

Answer 1

我会尝试递归。从左上角开始。如果您找到偶数，请重复调用跟踪计数的方法，只能在行中或下一行中查看。

递归签名可能是：

  int getMaxSameNeibors(int valueToMatch, int numberFoundSoFar,
        int[][] array, int currentIndex0, int currentIndex1){

  }

挑战如下：

有5个相邻的“2”，但不要在2,3处重复计数，因为它是2,2和3,1的邻居。为此，您可能需要将找到的位置列表传递给递归。

修改

我意识到这对以下情况不会有效......

2 5 8 7 1 3 2 2 2 7 3 3 2 0 3 8 0 1 5 7

因此，你需要检查同一行右一行，一行向上一行，向下一行（左1，直接在2和右1之下）。因此，我认为您需要传递已找到的值索引列表。

Answer 2

我可能会考虑对此进行递归处理。

你知道＆＃39;匹配＆＃39;四个可以在两个方向上，向下，向左，向右和对角线。这在很大程度上是低效的，但首先要想到的是：

在check(int value, int j, int i, int deltaJ, int deltaI, int count);

中的每个int调用方法randomTable[][]

循环遍历整个随机数数组的循环：

for (int i = 0; i < randomTable.length; i++) {
    for (int j = 0; j < randomTable[i].length; j++) {
        boolean a = check(randomTable[i][j], j, i, 1, 0, 1); // move right 
        System.out.print(a ? "The number " + randomTable[i][j] + "is in a line!" : );
    }
}

然后，递归循环看起来像这样：

boolean check(int value, int j, int i, int deltaJ, int deltaI, int count) {
    if (count == 4) {
        return true;
    }

    try {
        if (randomTable[i + deltaI][j + deltaJ] == value) {
            return check(randomTable[i + deltaI][j + deltaJ], j + deltaJ, i + deltaI, deltaJ, deltaI, count + 1);
        } else {
            return false;
        }
    } catch (ArrayIndexOutOfBoundsException e) {
        return false;
    }
}

Answer 3

想想看，你希望你的测试何时返回真实？如果连续，连续或对角连续出现偶数。如果它们都出现在同一行中，则它们具有相同的行号和连续的列号。

同样，如果它们出现在同一列中，则它们具有相同的列和连续的行。通过扩展，您认为您如何对待桌子的对角线？

Answer 4

詹姆斯·泰勒的回答可能是最好的，但也非常复杂。如果你的矩阵总是5x5那么：

每个行或列的

：元素1,2和3必须相同才能成为＆＃34; hit＆＃34;。检查这个，如果是，检查元素0或4是否也是那个数字。如果是这样，你有一个打击

那些将是2个相当简单的循环！

然后你需要两个以上的对角线，从左上角到右下角，从右上角到左下角。两种变体都可以容纳4种可能的命中。那些循环也不复杂

如果您的矩阵可以是动态大小，那么请使用递归或创建循环来检查当前数字和以下3

Answer 5

我会编写一个方法，检查给定方向上给定数字的序列，由dx（方向x）和dy（方向y）参数给出：

boolean checkSequence(int[][] table, int number, int x, int y, int dx, int dy) {...}

然后你只需要确定哪个方向以及哪个位置有足够的空间容纳该方向的序列并检查所有偶数。这是代码：

import java.util.Arrays;

public class Sequence
{
    // which axis is x and y and in which direction depends on your own preference,
    // just need to be consistent (applies to the whole program)
    static final int[][] directions = {{1,0},{1,1},{0,1}};

    static final boolean checkSequence(int[][] table, int number, int x, int y, int dx, int dy)
    {
        for(int i=0;i<4;i++) {if(table[y+dy*i][x+dx*i]!=number) return false;}
        return true;
    }

    public static void main(String[] args)
    {
        while(true)
        {
            int[][] randomTable = new int[5][5];
            for (int row = 0; row < randomTable.length; row++)
            {
                for (int column = 0; column < randomTable[row].length; column++)
                {
                    randomTable[row][column] = (int)(Math.random() * 10 + 0);
                }
            }
            for(int d=0;d<directions.length;d++)
            {
                int dx = directions[d][0];
                int dy = directions[d][1];
                // determine starting points where you have enough space to allow for a sequence at least 4 numbers long
                for(int y=0;y<randomTable.length-dy*3;y++)
                {
                    for(int x=0;x<randomTable[y].length-dx*3;x++)
                    {
                        for(int i=0;i<=10;i+=2)
                        {
                            if(checkSequence(randomTable, i, x, y,dx,dy))
                            {
                                for (int row = 0; row < randomTable.length; row++)
                                {
                                    for (int column = 0; column < randomTable[row].length; column++)
                                    {
                                        System.out.print(randomTable[row][column] + " ");
                                    }
                                    System.out.println();
                                }

                                System.out.println("Heureka! Found sequence of number "+i+
                                        " at position "+x+","+y+" in direction "+dx+" "+dy);
                                return;
                            }
                        }
                    }
                }
            }
        }
    }
}

我如何创建这个循环来检查数组中的整数？

5 个答案: