(fn gol [input]
  (let [b ((comp dec count) input)
        r ((comp dec count) (first input))
        board (->> input
                   (map seq)
                   (map #(replace {\space :dead \# :live} %))
                   (mapv (partial into [])))
        neighbors (fn [[i j]]
                    (into [] (for [i' [(dec i) i (inc i)]
                                   j' [(dec j) j (inc j)]
                                   :when (and (<= 0 i' b) (<= 0 j' r) (not= [i j] [i' j']))]
                               [i' j'])))
        next-state (fn [[status neighbors]]
                     (let [live-neighbors (->> (map (fn [[i j]]
                                                      (nth (nth board i) j)) neighbors)
                                               (filter (partial = :live))
                                               count)]
                       (if (= status :live)
                         (cond (< live-neighbors 2) " "
                               (<= 2 live-neighbors 3) "#"
                               :else " ")
                         (cond (= live-neighbors 3) "#"
                               :else " "))))]
    (->> board
         (map-indexed (fn [i row] (map-indexed (fn [j elem] [elem [i j]]) row)))
         (map (partial map #(vector (first %) (neighbors (last %)))))
         (map (partial map next-state))
         (mapv clojure.string/join))))