|
1
|
|
|
""" |
|
2
|
|
|
Project Euler Problem 11: Largest Product In A Grid |
|
3
|
|
|
=================================================== |
|
4
|
|
|
|
|
5
|
|
|
.. module:: solutions.problem11 |
|
6
|
|
|
:synopsis: My solution to problem #11. |
|
7
|
|
|
|
|
8
|
|
|
The source code for this problem can be |
|
9
|
|
|
`found here <https://bitbucket.org/nekedome/project-euler/src/master/solutions/problem11.py>`_. |
|
10
|
|
|
|
|
11
|
|
|
Problem Statement |
|
12
|
|
|
################# |
|
13
|
|
|
|
|
14
|
|
|
In the :math:`20 \\times 20` grid below, four numbers along a diagonal line have been marked in red. |
|
15
|
|
|
|
|
16
|
|
|
.. math:: |
|
17
|
|
|
|
|
18
|
|
|
08,02,22,97,38,15,00,40,00,75,04,05,07,78,52,12,50,77,91,08 \\\\ |
|
19
|
|
|
49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,04,56,62,00 \\\\ |
|
20
|
|
|
81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,03,49,13,36,65 \\\\ |
|
21
|
|
|
52,70,95,23,04,60,11,42,69,24,68,56,01,32,56,71,37,02,36,91 \\\\ |
|
22
|
|
|
22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80 \\\\ |
|
23
|
|
|
24,47,32,60,99,03,45,02,44,75,33,53,78,36,84,20,35,17,12,50 \\\\ |
|
24
|
|
|
32,98,81,28,64,23,67,10,\\color{red}{26},38,40,67,59,54,70,66,18,38,64,70 \\\\ |
|
25
|
|
|
67,26,20,68,02,62,12,20,95,\\color{red}{63},94,39,63,08,40,91,66,49,94,21 \\\\ |
|
26
|
|
|
24,55,58,05,66,73,99,26,97,17,\\color{red}{78},78,96,83,14,88,34,89,63,72 \\\\ |
|
27
|
|
|
21,36,23,09,75,00,76,44,20,45,35,\\color{red}{14},00,61,33,97,34,31,33,95 \\\\ |
|
28
|
|
|
78,17,53,28,22,75,31,67,15,94,03,80,04,62,16,14,09,53,56,92 \\\\ |
|
29
|
|
|
16,39,05,42,96,35,31,47,55,58,88,24,00,17,54,24,36,29,85,57 \\\\ |
|
30
|
|
|
86,56,00,48,35,71,89,07,05,44,44,37,44,60,21,58,51,54,17,58 \\\\ |
|
31
|
|
|
19,80,81,68,05,94,47,69,28,73,92,13,86,52,17,77,04,89,55,40 \\\\ |
|
32
|
|
|
04,52,08,83,97,35,99,16,07,97,57,32,16,26,26,79,33,27,98,66 \\\\ |
|
33
|
|
|
88,36,68,87,57,62,20,72,03,46,33,67,46,55,12,32,63,93,53,69 \\\\ |
|
34
|
|
|
04,42,16,73,38,25,39,11,24,94,72,18,08,46,29,32,40,62,76,36 \\\\ |
|
35
|
|
|
20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,04,36,16 \\\\ |
|
36
|
|
|
20,73,35,29,78,31,90,01,74,31,49,71,48,86,81,16,23,57,05,54 \\\\ |
|
37
|
|
|
01,70,54,71,83,51,54,69,16,92,33,48,61,43,52,01,89,19,67,48 |
|
38
|
|
|
|
|
39
|
|
|
The product of these numbers is |
|
40
|
|
|
:math:`\\color{red}{26} \\times \\color{red}{63} \\times \\color{red}{78} \\times \\color{red}{14} = 1788696`. |
|
|
|
|
|
|
41
|
|
|
|
|
42
|
|
|
What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in |
|
|
|
|
|
|
43
|
|
|
the :math:`20 \\times 20` grid? |
|
44
|
|
|
|
|
45
|
|
|
Solution Discussion |
|
46
|
|
|
################### |
|
47
|
|
|
|
|
48
|
|
|
Multiplication is associative, which means 'up' and 'down' are equivalent as are 'left' and 'right'. This means we |
|
|
|
|
|
|
49
|
|
|
can simply consider the vertical and horizontal cases to cover all four directions. Similarly, this logic reduces the |
|
|
|
|
|
|
50
|
|
|
number of diagonal directions; 'lower left to upper right' is equivalent to 'upper right to lower left', and 'upper left |
|
|
|
|
|
|
51
|
|
|
to lower right' is equivalent to 'lower right to upper left'. |
|
52
|
|
|
|
|
53
|
|
|
So, simply search (exhaustively) for the greatest product in each of these four cases and then find the maximum of |
|
|
|
|
|
|
54
|
|
|
those four scores. |
|
55
|
|
|
|
|
56
|
|
|
Solution Implementation |
|
57
|
|
|
####################### |
|
58
|
|
|
|
|
59
|
|
|
.. literalinclude:: ../../solutions/problem11.py |
|
60
|
|
|
:language: python |
|
61
|
|
|
:lines: 64- |
|
62
|
|
|
""" |
|
63
|
|
|
|
|
64
|
|
|
from functools import reduce |
|
65
|
|
|
from operator import mul |
|
66
|
|
|
from typing import List |
|
67
|
|
|
|
|
68
|
|
|
|
|
69
|
|
|
def horizontal(grid: List[List[int]], run_len: int) -> int: |
|
70
|
|
|
""" Find the maximal `run_len` long product in the horizontal direction |
|
71
|
|
|
|
|
72
|
|
|
:param grid: the two-dimensional integer grid |
|
73
|
|
|
:param run_len: the product run-length |
|
74
|
|
|
:return: the maximum `run_len` long product in the horizontal direction from `grid` |
|
75
|
|
|
""" |
|
76
|
|
|
|
|
77
|
|
|
answer = 0 |
|
78
|
|
|
n, m = len(grid), len(grid[0]) |
|
|
|
|
|
|
79
|
|
|
for i in range(n): |
|
80
|
|
|
for j in range(m - run_len + 1): |
|
81
|
|
|
subset = grid[i][j:j+run_len] |
|
82
|
|
|
product = reduce(mul, subset, 1) |
|
83
|
|
|
answer = max(answer, product) |
|
84
|
|
|
return answer |
|
85
|
|
|
|
|
86
|
|
|
|
|
87
|
|
View Code Duplication |
def vertical(grid: List[List[int]], run_len: int) -> int: |
|
|
|
|
|
|
88
|
|
|
""" Find the maximal `run_len` long product in the vertical direction |
|
89
|
|
|
|
|
90
|
|
|
:param grid: the two-dimensional integer grid |
|
91
|
|
|
:param run_len: the product run-length |
|
92
|
|
|
:return: the maximum `run_len` long product in the vertical direction from `grid` |
|
93
|
|
|
""" |
|
94
|
|
|
|
|
95
|
|
|
answer = 0 |
|
96
|
|
|
n, m = len(grid), len(grid[0]) |
|
|
|
|
|
|
97
|
|
|
for i in range(n - run_len + 1): |
|
98
|
|
|
for j in range(m): |
|
99
|
|
|
product = 1 |
|
100
|
|
|
for k in range(run_len): |
|
101
|
|
|
product *= grid[i+k][j] |
|
102
|
|
|
answer = max(answer, product) |
|
103
|
|
|
return answer |
|
104
|
|
|
|
|
105
|
|
|
|
|
106
|
|
View Code Duplication |
def diagonal_natural(grid: List[List[int]], run_len: int) -> int: |
|
|
|
|
|
|
107
|
|
|
""" Find the maximal `run_len` long product in the 'natural' diagonal direction |
|
108
|
|
|
|
|
109
|
|
|
The 'natural' diagonal is defined as top-left to bottom-right when viewed in the C-array style convention. |
|
|
|
|
|
|
110
|
|
|
|
|
111
|
|
|
:param grid: the two-dimensional integer grid |
|
112
|
|
|
:param run_len: the product run-length |
|
113
|
|
|
:return: the maximum `run_len` long product in the natural diagonal direction from `grid` |
|
114
|
|
|
""" |
|
115
|
|
|
|
|
116
|
|
|
answer = 0 |
|
117
|
|
|
n, m = len(grid), len(grid[0]) |
|
|
|
|
|
|
118
|
|
|
for i in range(n - run_len+1): |
|
119
|
|
|
for j in range(m - run_len+1): |
|
120
|
|
|
product = 1 |
|
121
|
|
|
for k in range(run_len): |
|
122
|
|
|
product *= grid[i+k][j+k] |
|
123
|
|
|
answer = max(answer, product) |
|
124
|
|
|
return answer |
|
125
|
|
|
|
|
126
|
|
|
|
|
127
|
|
View Code Duplication |
def diagonal_reverse(grid: List[List[int]], run_len: int) -> int: |
|
|
|
|
|
|
128
|
|
|
""" Find the maximal `run_len` long product in the 'reverse' diagonal direction |
|
129
|
|
|
|
|
130
|
|
|
The 'reverse' diagonal is defined as bottom-left to top-right when viewed in the C-array style convention. |
|
|
|
|
|
|
131
|
|
|
|
|
132
|
|
|
:param grid: the two-dimensional integer grid |
|
133
|
|
|
:param run_len: the product run-length |
|
134
|
|
|
:return: the maximum `run_len` long product in the reverse diagonal direction from `grid` |
|
135
|
|
|
""" |
|
136
|
|
|
|
|
137
|
|
|
answer = 0 |
|
138
|
|
|
n, m = len(grid), len(grid[0]) |
|
|
|
|
|
|
139
|
|
|
for i in range(run_len - 1, n): |
|
140
|
|
|
for j in range(m - run_len+1): |
|
141
|
|
|
product = 1 |
|
142
|
|
|
for k in range(run_len): |
|
143
|
|
|
product *= grid[i-k][j+k] |
|
144
|
|
|
answer = max(answer, product) |
|
145
|
|
|
return answer |
|
146
|
|
|
|
|
147
|
|
|
|
|
148
|
|
|
def solve(): |
|
149
|
|
|
""" Compute the answer to Project Euler's problem #11 """ |
|
150
|
|
|
|
|
151
|
|
|
# Build two-dimensional array of integers |
|
152
|
|
|
grid = """ |
|
153
|
|
|
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 |
|
154
|
|
|
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 |
|
155
|
|
|
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 |
|
156
|
|
|
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 |
|
157
|
|
|
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 |
|
158
|
|
|
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 |
|
159
|
|
|
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 |
|
160
|
|
|
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 |
|
161
|
|
|
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 |
|
162
|
|
|
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 |
|
163
|
|
|
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 |
|
164
|
|
|
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 |
|
165
|
|
|
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 |
|
166
|
|
|
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 |
|
167
|
|
|
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 |
|
168
|
|
|
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 |
|
169
|
|
|
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 |
|
170
|
|
|
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 |
|
171
|
|
|
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 |
|
172
|
|
|
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 |
|
173
|
|
|
""" |
|
174
|
|
|
grid = [row.strip() for row in grid.split("\n")] |
|
175
|
|
|
grid = [[int(cell) for cell in row.split(" ")] for row in grid if row != ""] |
|
176
|
|
|
|
|
177
|
|
|
# Search for maximal run_len long products in each direction |
|
178
|
|
|
run_len = 4 |
|
179
|
|
|
answers = [horizontal(grid, run_len), vertical(grid, run_len), |
|
180
|
|
|
diagonal_natural(grid, run_len), diagonal_reverse(grid, run_len)] |
|
181
|
|
|
|
|
182
|
|
|
# Identify the maximum of those partial answers |
|
183
|
|
|
answer = max(answers) |
|
184
|
|
|
return answer |
|
185
|
|
|
|
|
186
|
|
|
|
|
187
|
|
|
expected_answer = 70600674 |
|
|
|
|
|
|
188
|
|
|
|
Loading history...
This check looks for lines that are too long. You can specify the maximum line length.