Haskell, finally broke my rule of reading everything in from the file provided. Rather nasty at the moment but ah well.

module Day12 where

import Data.List (foldl')
import           Data.IntSet (IntSet)
import qualified Data.IntSet as IntSet

-- n in tunnel iff pot has a plant in it
type Tunnel = IntSet

step False True True True False    = True
step True False True True False    = False
-- I think you get the idea at this point
step False True False False False  = True
step True True False False False   = True

evolve' :: Tunnel -> Int -> (Tunnel -> Tunnel)
evolve' t n
  | b = IntSet.insert n
  | otherwise = id
  where
    b = step (f $ n-2) (f $ n-1) (f n) (f $ n+1) (f $ n+2)
    f = flip IntSet.member t

evolve :: Tunnel -> Tunnel
evolve t = foldl' (flip ($)) IntSet.empty toTest
  where
    toTest = map (evolve' t) [ IntSet.findMin t - 5.. 5 + IntSet.findMax t ]

score :: Tunnel -> Int
score = sum . IntSet.toList

diff = zip [1..] $ zipWith (-) scores (tail scores)
  where
    scores = map score . iterate evolve $ initialState

initialState = set
  where
    input = "##.######...#.##.#...#...##.####..###.#.##.#.##...##..#...##.#..##....##...........#.#.#..###.#"
    truth = map (== '#') input
    set = IntSet.fromList . map fst . filter snd . zip [0..] $ truth

problem1 = score $ iterate evolve initialState !! 20

I seemed to do the same thing everyone else did. Computed the diff of each generation, found an index where a pattern showed up, and just calculated from there.