1
\$\begingroup\$

Project Euler 11 Solution in Java. The problem is at https://projecteuler.net/problem=11

package coderbyte;

public class Java {

public static void main(String[] args) {

    int Grid[][] = {
            { 8, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52,
                    12, 50, 77, 91, 8 },
            { 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, 8, 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, 9, 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, 9, 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, 8, 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, 8, 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 } };

    int currentHorizProduct = 1;
    int currentVertiProduct = 1;
    int currentDiag1Product = 1;
    int currentDiag2Product = 1;

    // Horizontally

    for (int row = 0; row < Grid.length; row++) {
        int product = 1;
        int counter = 0;
        for (int column = 0; column < Grid[row].length; column++) {

            product = Grid[row][column] * product;
            counter++;
            if (counter == 4) {
                if (currentHorizProduct < product) {
                    currentHorizProduct = product;
                }
                if (Grid[row][column - 3] == 0) {
                    product = Grid[row][column] * Grid[row][column - 1]
                            * Grid[row][column - 2];
                } else {
                    product = product / Grid[row][column - 3];
                }
                counter = 3;
            }

        }
    }

    System.out.println(currentHorizProduct);

    // Vertically

    for (int row = 0; row < Grid.length; row++) {
        int product = 1;
        int counter = 0;
        for (int column = 0; column < Grid[row].length; column++) {

            product = Grid[column][row] * product;
            counter++;
            if (counter == 4) {
                if (currentVertiProduct < product) {
                    currentVertiProduct = product;
                }
                if (Grid[column - 3][row] == 0) {
                    product = Grid[column][row] * Grid[column - 1][row]
                            * Grid[column - 2][row];
                } else {
                    product = product / Grid[column - 3][row];
                }
                counter = 3;
            }

        }
    }

    System.out.println(currentVertiProduct);

    // Diagonally right

    for (int row = 0; row <= Grid.length - 4; row++) {
        for (int column = 0; column <= Grid[row].length - 4; column++) {

            int product = Grid[row][column] * Grid[row + 1][column + 1]
                    * Grid[row + 2][column + 2] * Grid[row + 3][column + 3];

            if (currentDiag1Product < product) {
                currentDiag1Product = product;
            }
        }
    }

    System.out.println(currentDiag1Product);

    // Diagonally left

    for (int row = 0; row < Grid.length - 3; row++) {
        for (int column = 3; column < Grid[row].length; column++) {

            int product = Grid[row][column] * Grid[row + 1][column - 1]
                    * Grid[row + 2][column - 2] * Grid[row + 3][column - 3];

            if (currentDiag2Product < product) {
                currentDiag2Product = product;
            }
        }
    }

    System.out.println(currentDiag2Product);

    System.out.println("Max result is : "
            + Math.max(Math.max(currentVertiProduct, currentHorizProduct),
                    Math.max(currentDiag1Product, currentDiag2Product)));

}

}

Any tips on how to improve the "Diagonal" part.... and probably shorten the code....

\$\endgroup\$
3
\$\begingroup\$

You're doing all of the different kinds of products independently. That's a lot of code duplication, and ends up hiding what the goal of the project is.

We want to find the max product. That suggests the following structure:

int best = 0;
for (int row = 0; row < Grid.length; ++row) {
    for (int col = 0; col < Grid[row].length; ++col) {
        best = Math.max(best, productAt(Grid, row, col));
    }
}

System.out.println("Max result is : " + best)

Okay, that's pretty simple. We just have a double loop looking for best. That just leaves productAt(). That's a function that takes the starting point and returns the largest possible product starting from there. Once you reduce the problem to just one source point, then it's not so bad:

int productAtIter(int [][] Grid, int row, int col, int drow, int dcol)
{
    if (row + 3 * drow >= 0 && row + 3 * drow < Grid.length &&
        col + 3 * drow >= 0 && col + 3 * drow < Grid[row].length)
    {
        int prod = 1;
        for (int i = 0; i < 4; ++i) {
            prod *= Grid[row + i * drow][col + i * dcol];
        }
        return prod;
    }
    else
    {
        return 0;
    }
}

int productAt(int[][] Grid, int row, int col)
{
    best = 0;

    // horizontal
    best = Math.max(best, productAtIter(Grid, row, col, +1, 0);

    // vertical
    best = Math.max(best, productAtIter(Grid, row, col, 0, +1);

    // diagonal-right
    best = Math.max(best, productAtIter(Grid, row, col, +1, +1);

    // diagonal-left
    best = Math.max(best, productAtIter(Grid, row, col, +1, -1);

    return best;
}
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.