text: """
  What is the greatest product of four adjacent numbers (horizontally,
  vertically, or diagonally) in this 20x20 array?
  
  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
  """
  
  from __future__ import print_function
  import os
  
  try:
      xrange  # Python 2
  except NameError:
      xrange = range  # Python 2
  
  
  def largest_product(grid):
      nColumns = len(grid[0])
      nRows = len(grid)
  
      largest = 0
      lrDiagProduct = 0
      rlDiagProduct = 0
  
      # Check vertically, horizontally, diagonally at the same time (only works
      # for nxn grid)
      for i in xrange(nColumns):
          for j in xrange(nRows - 3):
              vertProduct = (
                  grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
              )
              horzProduct = (
                  grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]
              )
  
              # Left-to-right diagonal (\) product
              if i < nColumns - 3:
                  lrDiagProduct = (
                      grid[i][j]
                      * grid[i + 1][j + 1]
                      * grid[i + 2][j + 2]
                      * grid[i + 3][j + 3]
                  )
  
              # Right-to-left diagonal(/) product
              if i > 2:
                  rlDiagProduct = (
                      grid[i][j]
                      * grid[i - 1][j + 1]
                      * grid[i - 2][j + 2]
                      * grid[i - 3][j + 3]
                  )
  
              maxProduct = max(
                  vertProduct, horzProduct, lrDiagProduct, rlDiagProduct
              )
              if maxProduct > largest:
                  largest = maxProduct
  
      return largest
  
  
  def solution():
      """Returns the sum of all the multiples of 3 or 5 below n.
      
      >>> solution()
      70600674
      """
      grid = []
      with open(os.path.dirname(__file__) + "/grid.txt") as file:
          for line in file:
              grid.append(line.strip("\n").split(" "))
  
      grid = [[int(i) for i in grid[j]] for j in xrange(len(grid))]
  
      return largest_product(grid)
  
  
  if __name__ == "__main__":
      print(solution())
  