# Largest product in a grid

```ruby
var text = <<'EOT'
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
EOT
 
func horizontal(N, i, j, matrix) {
    N.of {|k| matrix[i][j+k] }
}
 
func diagonal(N, i, j, matrix) {
    N.of {|k| matrix[i+k][j+k] }
}
 
var matrix = Matrix(text.lines.map{ .nums }...)
 
var reversed_matrix   = matrix.horizontal_flip
var transposed_matrix = matrix.transpose
 
define (
    CHECK_DIAGONALS = false   # true to also check diagonals
)
 
const e = matrix.end
 
for N in (1..6) {
 
    var products = gather {
        for i in (0..e), j in (0..e) {
 
            (j+N < e) || next
 
            # Horizontal and vertical
            take(horizontal(N, i, j, matrix))
            take(horizontal(N, i, j, transposed_matrix))
 
            CHECK_DIAGONALS || next
            (i+N < e)       || next
 
            # Left-to-right and right-to-left diagonals
            take(diagonal(N, i, j, matrix))
            take(diagonal(N, i, j, reversed_matrix))
        }
    }
 
    var nums = products.max_by { .prod }
    say "Largest product of #{N} adjacent elements: prod(#{nums}) = #{nums.prod}"
}
```

#### Output:

```
Largest product of 1 adjacent elements: prod([99]) = 99
Largest product of 2 adjacent elements: prod([95, 97]) = 9215
Largest product of 3 adjacent elements: prod([91, 88, 97]) = 776776
Largest product of 4 adjacent elements: prod([66, 91, 88, 97]) = 51267216
Largest product of 5 adjacent elements: prod([62, 99, 69, 82, 67]) = 2326829868
Largest product of 6 adjacent elements: prod([99, 69, 82, 67, 59, 85]) = 188210512710
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://trizen.gitbook.io/sidef-lang/programming_tasks/l/largest_product_in_a_grid.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.