Creative Scratchpad

In the 20×20 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 20×20 grid?

This particular task doesn't leave much space for imagination, and as zeros are included, it doesn't make sense to use previous products to speed it up a little bit. So, we'll keep it simple, with just one array of all the numbers (knowing the column count, we don't have to have each row as one array) we will iterate over the horizontals, verticals and in both diagonal ways. We already know the value of one of the non-zero products so we can use it as an initial value for our maximum. For the iterators, only additions would do (well, to keep it short, I'll use 2*colCount instead of colCount + colCount) and then we just multiply the four values. Easy this time.

Just for the fun of I've used fileStream this time, at least it keeps me from repeating the exact same code as the last time.

(
    fn getGrid filePath =
    (
        local row, lineNr = 1
        local result = #()
        local file = openFile filePath
        while NOT EOF file do
        (
            row = (filterString (readLine file) " ")
            join result (for i = 1 to row.count collect row[i] as integer)
            lineNr += 1
        )
        close file
        result
    )

    fn iterateOverGrid grid rowCount:20 colCount:20 =
    (
        local maxProduct = 1788696

        -- horizontal
        for i = 0 to (rowCount - 1) do
        (
            local index = i*colCount
            local horMax = amax \
                (for j = 1 to (colCount - 3) collect
                    grid[index += 1]*grid[index+1]*grid[index+2]*grid[index+3])

            if horMax > maxProduct do
                maxProduct = horMax
        )

        -- vertical
        for i = 1 to colCount do
        (
            local index = i
            local verMax = amax \
                (for j = 0 to (rowCount - 4) collect
                    grid[index]*grid[index += colCount]*grid[index+colCount]*grid[index+2*colCount])

            if verMax > maxProduct do
                maxProduct = verMax
        )

        -- diagonal 1
        for i = 0 to (rowCount - 4) do
        (
            local index = i*colCount
            local diff = colCount + 1
            local diagMax1 = amax \
                (for j = 1 to (colCount - 3) collect
                    grid[index += 1]*grid[index+diff]*grid[index+2*diff]*grid[index+3*diff])        

            if diagMax1 > maxProduct do
                maxProduct = diagMax1
        )

        -- diagonal 2
        for i = 3 to (rowCount - 1) do
        (
            local index = i*colCount
            local diff = colCount - 1
            local diagMax2 = amax \
                (for j = 1 to (colCount - 3) collect
                    grid[index += 1]*grid[index-diff]*grid[index-2*diff]*grid[index-3*diff])

            if diagMax2 > maxProduct do
                maxProduct = diagMax2
        )

        maxProduct
    )

    testGrid = getGrid "Z:\Euler\prob11.txt"
    iterateOverGrid testGrid
)

DISCLAIMER: All scripts and snippets are provided as is under Creative Commons Zero (public domain, no restrictions) license. The author and this blog cannot be held liable for any loss caused as a result of inaccuracy or error within these web pages. Use at your own risk.