# How to approach this problem?

• 04-26-2012, 03:41 PM
Zigster
How to approach this problem?
Hello, I am working on a new Euler Project Problem, but I'm not exactly sure how to approach it.

The problem:
Quote:

In the 2020 grid below, four numbers along a diagonal line have been marked in red.

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
The product of these numbers is 26 63 78 14 = 1788696.

What is the greatest product of four adjacent numbers in any direction (up, down, left, right, or diagonally) in the 2020 grid?
This is what I have so far:
Code:

```public class Problem011 {         public static void main (String[] args){                 int x, y, z, a, b;                 b = 0;                                 int row1[]={8, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 8};                                 for (x=0;x<row1.length-4;x++){                         z=1;                         y=0;                         for (a=0;a<4;a++){                                                                 y=x;                                 y+=a;                                 z*=row1[y];                                                         }                                                 if (z>b){                                 b=z;                         }                 }                 System.out.println("b: " + b);         } }```
It finds the greatest product of four adjacent numbers along the row.

But I don't know how to apply it to columns or diagonals?

Cheers!
• 04-26-2012, 04:11 PM
jlczuk
Re: How to approach this problem?
If you have an 20 by 20 two dimensional array, and you are working on the number at x=6, y=6, what values for x and y give you the adjacent numbers in each of the 8 directions? Now break it down, how do you get the next number in the same direction for a given direction?

For what you've deduced so far, you've only worked on a row, which only varies the value of the x-index in one direction or the other (x-1 = left and x+1 = right).
• 04-26-2012, 05:06 PM
k1ng
Re: How to approach this problem?
Let shorten the problem for simplicity to a 3x3 square and you want the greatest product of two numbers...

2 4 6
7 6 5
3 5 8

Create an array to hold it:-

Code:

`int[][] grid = new int[][] {  {2, 4, 6,}, {7,6,5}, {3,5,8}  } ;`
If you go through each number in the grid

Code:

``` for (int x=0; x<grid.length; x+){   for (int y=0; y<grid.length; y+){     //code goes here   }  }```
and then you multiply each number by that to it's right, it's bottom right, it's bottom and it's bottom left

(why it's decided to add some google rubbish in here I don't know)
Code:

``` long pR = grid[x][y] * grid[x+1][y];  long pBR = grid[x][y] * grid[x+1][y+1];  long pB = grid[x][y] * grid[x][y+1];  long pBL = grid[x][y] * grid[x-1][y+1];```
keep an overall max outside the loop and which direction the line goes, lets say 1=right, 2=down right, 3=down, 5 down left which you update everytime one of your products is greater than max

Code:

``` long max = 0;  int maxX = -1;  int maxY = -1;  int maxD = -1;```
...then add some error trapping so that you dont measure past the edges of the grid.

But the easiest way to do this is recursivley.
• 04-26-2012, 05:30 PM
Zigster
Re: How to approach this problem?
Thanks jlczuk! I didn't know you could make multidimensional arrays!

I have made new code to check all rows:

Code:

```public class Problem011 {         public static void main (String[] args){                 int x, y, z, a, b, c;                 b = 0;                                 int NumGrid[] []= new int [] []                                 {{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},                                 {1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48,}};                                 for (c=0;c<20;c++){                                         for (x=0;x<NumGrid.length-3;x++){                                 z=1;                                 y=0;                                 System.out.println(x);                                                                 for (a=0;a<4;a++){                                                                                 y=x;                                         y+=a;                                         z*=NumGrid[a][y];                                         System.out.println("y: " + y + "\t NumGrid: " + NumGrid[0][y]);                                                                         }                                                                 System.out.println("z: " + z);                                 if (z>b){                                         b=z;                                 }                         }                         System.out.println("b: " + b);                 }         } }```
I think I will have to make some new methods or else it will get too complicated.

I am still not sure how to check for diagonals though. If I start at NumGrid [0][0] and then set up a loop to go to NumGrid [1][1], NumGrid[2][2], NumGrid[3][3], and get it to loop down the rows, it wouldn't get all the diagonal fours.

I would have to check starting from each corner, going inwards, to not miss any.

That seems pretty complicated and inefficient?

Cheers!

Edit:

@King: Thanks! I missed your post before (had the page sitting open for awhile). Sorry I don't understand how you are saying I can get the diagonal 4 numbers? And can you explain what you mean by doing it recursively? I sort of know what recursion is(method that calls itself), but I've never done it so not sure how to implement it.

Thanks!
• 04-26-2012, 05:48 PM
k1ng
Re: How to approach this problem?
If you start at the top left and for every grid item you check TR,R,BR and B then you'll cover everything ( i said BL in my example, instead of TR but it doesn't matter)

For every square you check 4 steps in each direction. Your naming is a little confusing, I'd just use x,y to step through the grid and a to keep track of the muliples step like so

Code:

```int TR=1, R=1, BR=1, B=1; for (a=0;a<4;a++){   TR *= NumGrid[x+a][y-a];   R *= NumGrid[x+a][y];   BR *= NumGrid[x+a][y+a];   B *= NumGrid[x+a][y]; }```
• 04-26-2012, 05:56 PM
k1ng
Re: How to approach this problem?
As for recursion, it gets a little complex but it makes things simpler once you understand. It's probably too much to take in if you're stuggling with this problem but it would look something like...

Code:

```computeProductLine(int x, int y, int xStep, int yStep, int noSteps){   if (noSteps==0)     return NumGrid[x][y];  else     return computerProductLine(x+xStep, y+yStep, xStep, yStep, noSteps-1) * NumGrid[x][y]; }```
where you would only need to say

Code:

``` TR = computeProductLine(x,y,1,-1,4);  R = computeProductLine(x,y,1,0,4);  BR = computeProductLine(x,y,1,1,4);  B = computeProductLine(x,y,0,1,4);```
it's handy, but wait till you can grasp this stuff before moving onto recursion ;)
• 04-26-2012, 05:58 PM
Zigster
Re: How to approach this problem?
Oohhhhh, I get you now!

How do I "error trap"? With some nested if statements?

Cheers!
• 04-26-2012, 06:00 PM
k1ng
Re: How to approach this problem?
yea, just make sure your new value (i.e. x+a, y-a, etc) isn't greater than the size of the board or less than zero.
• 04-26-2012, 06:47 PM
Zigster
Re: How to approach this problem?
I'm getting pretty confused:

Code:

```public class Problem011 {         public static void main (String[] args){                 int x, y, R, BR = 0, a, b, c;                 int counter1, counter2;                 b = 0;                                 int NumGrid[] []= new int [] []                                 {{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},                                 {1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48,}};                                 for (c=0;c<20;c++){                                         for (x=0;x<NumGrid.length;x++){                                 R=1;                                 y=0;                                                                 for (a=0;a<4;a++){                                                                                 y=x;                                         y+=a;                                                                                 if(x<17){                                                                                 R*=NumGrid[c][y];                                                                                 }                                                                                 if (x<17 && c<17){                                                 BR*=NumGrid[a+1][y];                                                 System.out.println(NumGrid[a+1][y]);                                         }                                                                         }                                 System.out.println("\n");                                 if (R>b){                                         b=R;                                 }                         }                         System.out.println("b: " + b);                 }         } }```
BR stops when it prints: 4, 13, 36, 80. Which means it's stopping after the second row. I can't figure out why it's stopping?

EDIT: Ok I figured it out, I was printing the wrong thing. Should have been NumGrid[x+a][y]. I can see the light at the end of the tunnel!

EDIT: Ok, Think I have got it, but Project Euler website is down so I can't test it.
• 04-26-2012, 10:29 PM
k1ng
Re: How to approach this problem?
Ah good. :)
• 04-27-2012, 01:29 AM
Zigster
Re: How to approach this problem?
Well, the answer is wrong, but I can't see where I have made a mistake?

Code:

```public class Problem011 {         public static void main (String[] args){                 int R, BR, B, BL;                 BR = 1;                 B = 1;                 BL = 1;                 int y, a, b;                 int Row, Column;                 b = 0;                                 int NumGrid[] []= new int [] []                                 {{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},                                 {1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48,}};                                 for (Row=0;Row<20;Row++){                                         for (Column=0;Column<NumGrid.length;Column++){                                 R=1;                                 y=0;                                                                 for (a=0;a<4;a++){                                                                                 y=Column;                                         y+=a;                                                                                 if(Column<17)                                         {                                         R*=NumGrid[Row][y];                                         //System.out.println("a: " + a + "\ty: " + "\tNumGriday: " + NumGrid[Row][y]);                                         }                                                                                 if (Column<17 && Row<17)                                         {                                         BR*=NumGrid[Row + a][y];                                         //System.out.println("a: " + a + "\ty: " + y + "\tNumGriday: " + NumGrid[Row + a][y]);                                         }                                                                                 if(Column<17)                                         {                                         B *= NumGrid[y][Row];                                         //System.out.println("a: " + a + "\ty: " + "\tNumGriday: " + NumGrid[y][Row]);                                         }                                         if(Row>3 && Column<17){                                         BL*=NumGrid[y][Row-a];                                         //System.out.println("a: " + a + "\ty: " + "\tNumGriday: " + NumGrid[Row - a][Column + a]);                                         }                                                                         }                                 System.out.println("\n");                                 if (R>b){                                         b=R;                                 }                                 if (BR>b){                                         b=BR;                                 }                                 if (B>b){                                         b=B;                                 }                                 if (BL>b){                                         b=BL;                                 }                         }                         System.out.println("b: " + b);                 }         } }```
• 04-27-2012, 01:34 AM
jlczuk
Re: How to approach this problem?
My suggestion is to add the debug tracing back in. For each product, identify the starting number's coordinates in the grid and print out the numbers being multiplied and the answer. You will end up with one line for each product. From there you can inspect to see if you are grabbing the correct numbers for each product. It should give you some clues.
• 04-27-2012, 08:10 AM
Zigster
Re: How to approach this problem?
Thanks! I was so caught up in get the array stuff working I was ignoring the multiplication.

Because I was not resetting B, BR, BL, R back to 1 at the beginning of the loop, they weren't resetting and kept adding up. Once I set them to 1 at the beginning of the loop I got the right answer.

Code:

```public class Problem011 {         public static void main (String[] args){                 long R, BR, B, BL, b;                 int y, a;                 int Row, Column;                 b = 0;                                 int NumGrid[] []= new int [] []                                 {{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},                                 {1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48,}};                                 for (Row=0;Row<20;Row++){                                         for (Column=0;Column<NumGrid.length;Column++){                                 R=1;                                 y=0;                                 BL=1;                //This is what I changed                                 BR=1;                                 B=1;                                 R=1;                                                                 for (a=0;a<4;a++){                                                                                 y=Column;                                         y+=a;                                                                                 if(Column<17)                                         {                                         R*=NumGrid[Row][y];                                         //System.out.println("a: " + a + "\ty: " + "\tNumGriday: " + NumGrid[Row][y]);                                         }                                                                                 if (Column<17 && Row<17)                                         {                                         BR*=NumGrid[Row + a][y];                                         //System.out.println("a: " + a + "\ty: " + y + "\tNumGriday: " + NumGrid[Row + a][y]);                                         }                                                                                 if(Column<17)                                         {                                         B *= NumGrid[y][Row];                                         //System.out.println("a: " + a + "\ty: " + "\tNumGriday: " + NumGrid[y][Row]);                                         }                                                                                 if(Row>3 && Column<17){                                         BL*=NumGrid[Row - a][Column + a];                                         //System.out.println("a: " + a + "\ty: " + "\tNumGriday: " + NumGrid[Row - a][Column + a] + "\tBL: " + BL);                                         }                                                                         }                                 System.out.println("\n");                                 if (R>b){                                         b=R;                                 }                                 if (BR>b){                                         b=BR;                                 }                                 if (B>b){                                         b=B;                                 }                                 if (BL>b){                                         b=BL;                                 }                         }                         System.out.println("b: " + b);                 }         } }```
• 04-27-2012, 10:13 AM
k1ng
Re: How to approach this problem?
Firstly, I recommend cutting down repetition of code. For example you have...

Code:

``` if(Column<17)  {     //R   }   if (Column<17 && Row<17)   {     //BR   }   if(Column<17)   {     //B   }   if(Row>3 && Column<17){     //BL   }```
when you could have

Code:

``` if (Column<17)  {   //R   //B   if (Row<17)   {     //BR   }else if (Row>3){     //BL   }  }```

Secondly, this...

Code:

`BL*=NumGrid[Row - a][Column + a];`
isn't that the same as?

Code:

`BL*=NumGrid[Row - a][y];`
• 04-27-2012, 05:28 PM
Zigster
Re: How to approach this problem?
Thanks King! Yes Column + a is the same as y, so I don't need y, and those if statements are definitely cleaner.
• 04-27-2012, 05:33 PM
k1ng
Re: How to approach this problem?
Quote:

Originally Posted by Zigster
Thanks King! Yes Column + a is the same as y, so I don't need y, and those if statements are definitely cleaner.

Actually, my code had a vital error in it I just noticed, :P. Should have been...

Code:

```if (Column<17) {   //R   //B     if (Row<17)   {     //BR   }   if (Row>3){     //BL   } }```
• 04-27-2012, 05:53 PM
Zigster
Re: How to approach this problem?
Yeah, lol. Was just gonna say, I tried it but it gave the wrong answer.

Cheers!