# Project Euler Solution 11: Largest product in a grid

This is part of the Project Euler series, this is about Problem 11: Largest product in a grid. It is about finding a product of adjacent numbers in a grid.

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

[Grid]

The product of these numbers is 26 × 63 × 78 × 14 = 1788696.

What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?

This can be solved straightforwardly once the grid has been parsed. One needs to make sure that the leading zeros don't trick the parser into octal digits. And then one needs to be careful with the index manipulations. Luckily Python is rather robust here and would warn if one overstept the bounds.

```grid = '''
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
'''

def word_to_int(word: str) -> int:
if word[0] == "0":
return int(word[1:])
else:
return int(word)

def solution() -> int:
lines = grid.strip().split('\n')
cells = [[word_to_int(word) for word in line.split()] for line in lines]

maximum = 0

# Horizontal in row.
for row_i in range(20):
for col_i in range(16):
product = 1
for i in range(4):
product *= cells[row_i][col_i + i]
maximum = max(maximum, product)

# Vertical in column.
for row_i in range(16):
for col_i in range(20):
product = 1
for i in range(4):
product *= cells[row_i + i][col_i]
maximum = max(maximum, product)

# Diagonal.
for row_i in range(16):
for col_i in range(16):
product = 1
for i in range(4):
product *= cells[row_i + i][col_i + i]
maximum = max(maximum, product)

# Other diagonal.
for row_i in range(4, 20):
for col_i in range(16):
product = 1
for i in range(4):
product *= cells[row_i - i][col_i + i]
maximum = max(maximum, product)

return maximum
```

We get the correct solution of 70,600,674 within 673 µs, which is fast enough.