Question

我该怎么办？

问题13：网格产品

输入文件：Prob13.in.txt

输出：您的输出需要定向到stdout（即使用System.out.println（））

简介

每个人小时候连接四个，对吧？好吧，你可能会把这个问题称为“乘以四”。给定一个非负整数的正方形网格，您必须在任何方向（向上，向下，对角线，左，右）找到任意四个相邻数字的最大乘积。网格中的所有数字都将小于100。

节目输入

文件Prob06.in.txt将包含一个正方形的整数网格。同一行上的数字将由一个空格分隔。

示例输入：

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08

49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00

81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65

52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91

22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80

24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50

32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70

67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21

24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72

21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95

78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92

16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57

86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58

19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40

04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66

88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69

04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36

20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16

20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54

01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

节目输出

您的程序应使用下面显示的格式打印出网格中任意四个相邻数字的最佳产品。为清楚起见，上面突出显示了解决方案。

示例输出：

最佳产品：70600674

Answer 1

您可以将数据保存在由数组组成的矩阵中，然后查看矩阵每个数字的八个有效乘法。执行每次乘法并将其保存在ArrayList中，然后使用Collections类中的sort metoid。像这样：

private static ArrayList<Integer> numberList = new ArrayList<>();

public static void main(String[] args)
{
    int[][] matrix = new int[100][100];
    int j = 0;       
    int first = 0;
    int second = 0;
    int third = 0;
    int fourth = 0;
    int fifth = 0;
    int sixth = 0;
    int seventh = 0;
    int eight = 0;
    String[] lineSplit = null;

    try
    {
        BufferedReader br = new BufferedReader(new FileReader("C:\\\\StackOverflow\\file.txt"));
        try
        {
            StringBuilder sb = new StringBuilder();
            String line = br.readLine();

            while (line != null)
            {
                lineSplit = line.split(" ");
                for(int i = 0; i < lineSplit.length; i++)
                {
                    matrix[j][i] = Integer.valueOf(lineSplit[i]);
                }
                j++;
                line = br.readLine();
            }

            int a = 0;
            for(int i = 0;i < j; i++)
            {
                for(int k = 0;k < lineSplit.length; k++)
                {
                    try{first = matrix[i][k] * matrix[i-1][k-1] * matrix[i-2][k-2] * matrix[i-3][k-3];}catch(Exception e){first = 0;}
                    try{second = matrix[i][k] * matrix[i-1][k] * matrix[i-2][k] * matrix[i-3][k];}catch(Exception e){second = 0;}
                    try{third = matrix[i][k] * matrix[i-1][k+1] * matrix[i-2][k+2] * matrix[i-3][k+3];}catch(Exception e){third = 0;}
                    try{fourth = matrix[i][k] * matrix[i][k+1] * matrix[i][k+2] * matrix[i][k+3];}catch(Exception e){fourth = 0;}
                    try{fifth = matrix[i][k] * matrix[i+1][k+1] * matrix[i+2][k+2] * matrix[i+3][k+3];}catch(Exception e){fifth = 0;}
                    try{sixth = matrix[i][k] * matrix[i+1][k] * matrix[i+2][k] * matrix[i+3][k];}catch(Exception e){sixth = 0;}
                    try{seventh = matrix[i][k] * matrix[i+1][k-1] * matrix[i+2][k-2] * matrix[i+3][k-3];}catch(Exception e){seventh = 0;}
                    try{eight = matrix[i][k] * matrix[i][k-1] * matrix[i][k-2] * matrix[i][k-3];}catch(Exception e){eight = 0;}

                    addNumber(first);
                    addNumber(second);
                    addNumber(third);
                    addNumber(fourth);
                    addNumber(fifth);
                    addNumber(sixth);
                    addNumber(seventh);
                    addNumber(eight);
                }
            }

            Collections.sort(numberList);
            System.out.println("The greatest: " + numberList.get(numberList.size()-1));
        }
        finally
        {
            br.close();
        }
    }
    catch(FileNotFoundException e)
    {
        System.out.println("FileNotFoundException: " + e.getMessage());
    }
    catch(IOException e)
    {
        System.out.println("IOException: " + e.getMessage());
    }
}

private static void addNumber(int number)
{
    if(number > 0)
    {
        numberList.add(number);
    }
}

Answer 2

我认为解决这个问题需要了解的主要概念如下：使用两个while循环（一个嵌套），理解循环条件，someReader.hasNextLine方法，二维数组，理解循环的作用域，全局Int变量行计数器。

您将要使用文件阅读器系统地解析文件，我建议您查看Scanner类。

创建一个包含Int值的二维数组（取决于您是否有权访问数组列表，否则此步骤的难度会发生变化）。
从构建第一个while循环开始。使用阅读器添加条件检查，以检查文件中是否有.nextLine。如果为false，则循环应该停止
由于条件应为true，请使用fileReader使用.getNextLine方法并将该值保存到临时String变量。
获取该String，因为java中的所有String变量都是对象，他们可以访问您可以使用的预定义继承方法。使用.split（）方法。在调用方法时，我们需要创建一个临时数组来保存拆分令牌（值）。为你的第二个循环创建了一个计数器。
```
String[] tokenHolder = savedStringLineFromBuffer.split(" ");
Int counter = 0;
```
在第二个while循环中，检查tokenHolder数组的长度。如果计数器小于数组的长度，则使用计数器变量的值从tokenHolder获取当前令牌。
```
String tempString ="";

tokenHolder[counter] = tempString;

int tempInt = Integer.parseInt(tempString);

twoDimenArray[rowCounter][counter] = tempInt;
```
这应该将当前的String变量作为整数添加到2D数组中。
每行迭代后，您需要在行计数器上添加+1。这应该为您提供一个完整的二维数组，其中包含文本文件中每个值的Int值。
没有为你完成整个问题。您需要循环2D数组的每个元素并检查相邻的索引。获取第一个数字，每次获得4个相邻变量时，请检查此数字是否大于之前的数字。如果是这样，请将其保存到最后一个位置。
```
int valOne = twoDimenArray[row][col];
int valTwo = twoDimenArray[row][col];
int valThree = twoDimenArray[row][col];
int valFour = twoDimenArray[row][col];
```
只需获取产品，覆盖您的类的twoString方法并格式化输出。

在java中水平和垂直读取文本文件

2 个答案: