-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy path011.js
183 lines (136 loc) · 6.24 KB
/
011.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/**
* Largest Product in a Grid
* Computes the greatest product of four adjacent numbers in the same direction
*
* Ashen Gunaratne
* mail@ashenm.ml
*
*/
/**
* @constant
* @type {String}
*/
const grid = '0802229738150040007504050778521250779108'
+ '4949994017811857608717409843694804566200'
+ '8149317355791429937140675388300349133665'
+ '5270952304601142692468560132567137023691'
+ '2231167151676389419236542240402866331380'
+ '2447326099034502447533537836842035171250'
+ '3298812864236710263840675954706618386470'
+ '6726206802621220956394396308409166499421'
+ '2455580566739926971778789683148834896372'
+ '2136230975007644204535140061339734313395'
+ '7817532822753167159403800462161409535692'
+ '1639054296353147555888240017542436298557'
+ '8656004835718907054444374460215851541758'
+ '1980816805944769287392138652177704895540'
+ '0452088397359916079757321626267933279866'
+ '8836688757622072034633674655123263935369'
+ '0442167338253911249472180846293240627636'
+ '2069364172302388346299698267598574043616'
+ '2073352978319001743149714886811623570554'
+ '0170547183515469169233486143520189196748'
;
/**
* @function largest
* @summary Computes the largest product of four adjacent numbers
* @param {String} sequence - the YxY grid
* @param {Number} [digits=2] - the number of characters per product quantity
* @param {Number} [aperture=4] - the number of adjacent multipliers
* @description Returns the largest product of 'aperture' integers composed of specified 'digits' digits in the grid 'sequence'
*/
const largest = function computeLargestProduct(sequence, digits = 2, aperture = 4) {
// largest
let product = 0;
// grid parameters
const offsetY = aperture - 1;
const offsetX = offsetY * digits;
// grid geometry
const length = sequence.length;
const height = Math.sqrt(length / digits);
const width = digits * height;
// grid section markers
const bottom = width - offsetX;
const collectiveX = bottom - offsetX;
const collectiveY = height - offsetY;
const right = width * collectiveY;
const collectiveZ = right - offsetX;
const left = collectiveZ - collectiveX;
// horizontal offsets
const x1 = 2 * digits;
const x2 = 3 * digits;
// vertical offsets
const y1 = 2 * width;
const y2 = 3 * width;
// common centre section
for (let marker = offsetX, chunk = marker, ceil = marker + collectiveX; marker < collectiveZ;) {
let stage;
// horizontally
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk + digits, digits)
* +sequence.substr(chunk + x1, digits) * +sequence.substr(chunk + x2, digits);
if (stage > product) { product = stage; }
// vertically
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk + width, digits)
* +sequence.substr(chunk + y1, digits) * +sequence.substr(chunk + y2, digits);
if (stage > product) { product = stage; }
// diagonally
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk + digits + width, digits)
* +sequence.substr(chunk + x1 + y1, digits) * +sequence.substr(chunk + x2 + y2, digits);
if (stage > product) { product = stage; }
// anti-diagonally
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk - digits + width, digits)
* +sequence.substr(chunk - x1 + y1, digits) * +sequence.substr(chunk - x2 + y2, digits);
if (stage > product) { product = stage; }
// eol
if ((chunk += digits) === ceil) { chunk = (marker += width); ceil = marker + collectiveX; }
}
// left leftover
for (let marker = 0, chunk = marker, ceil = offsetX; marker < left;) {
let stage;
// horizontally
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk + digits, digits)
* +sequence.substr(chunk + x1, digits) * +sequence.substr(chunk + x2, digits);
if (stage > product) { product = stage; }
// vertically
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk + width, digits)
* +sequence.substr(chunk + y1, digits) * +sequence.substr(chunk + y2, digits);
if (stage > product) { product = stage; }
// diagonally
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk + digits + width, digits)
* +sequence.substr(chunk + x1 + y1, digits) * +sequence.substr(chunk + x2 + y2, digits);
if (stage > product) { product = stage; }
// eol
if ((chunk += digits) === ceil) { chunk = (marker += width); ceil = marker + offsetX; }
}
// right leftover
for (let marker = width - offsetX, chunk = marker, ceil = width; marker < right;) {
let stage;
// vertically
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk + width, digits)
* +sequence.substr(chunk + y1, digits) * +sequence.substr(chunk + y2, digits);
if (stage > product) { product = stage; }
// anti-diagonally
stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk - digits + width, digits)
* +sequence.substr(chunk - x1 + y1, digits) * +sequence.substr(chunk - x2 + y2, digits);
if (stage > product) { product = stage; }
// eol
if ((chunk += digits) === ceil) { chunk = (marker += width); ceil = marker + offsetX; }
}
// bottom leftover
for (let marker = right, chunk = marker, ceil = marker + bottom; marker < length;) {
// horizontally
let stage = +sequence.substr(chunk, digits) * +sequence.substr(chunk + digits, digits)
* +sequence.substr(chunk + x1, digits) * +sequence.substr(chunk + x2, digits);
if (stage > product) { product = stage; }
// eol
if ((chunk += digits) === ceil) { chunk = (marker += width); ceil = marker + bottom; }
}
return product;
};
// tests
console.assert(largest('11111111111111112222222211111111') === 234256, `expected 234256 got ${largest('11111111111111112222222211111111')}`);
console.assert(largest('11221111112211111122111111221111') === 234256, `expected 234256 got ${largest('11221111112211111122111111221111')}`);
console.assert(largest('22111111112211111111221111111122') === 234256, `expected 234256 got ${largest('22111111112211111111221111111122')}`);
console.assert(largest('11111199111199111199111199111111') === 96059601, `expected 96059601 got ${largest('11111199111199111199111199111111')}`);
// answer
console.log(largest(grid));