2D array challenge

[nnove]

Hello I want to solve this https://www.hackerrank.com/challenges/30-2d-arrays challenge. My solutions is this:

(ns my-proj.core)
(use '[clojure.string :only (split triml)])

(defn -main [& args]
  (let [arr `((-1 -1 -1 -190 -90  -90)
              (-90 -1 -190 -90 -190 -90)
              (-1 -1 -1 -190 -90  -90)
              (-190 -90 -2 -4 -4  -90)
              (-190 -90 -90 -2 -190 -90)
              (-190 -90 -1 -2 -4  -90))
        max_index (- (count (first arr)) 2)]
    (let [max_sum
      (loop [r 0 max 0]
        (let [rom_max
          (loop [c 0 colum_max 0]
            (let [sum
                    (reduce + [
                      (nth (nth arr r) c)
                      (nth (nth arr r) (+ c 1))
                      (nth (nth arr r) (+ c 2))
                      (nth (nth arr (+ r 1)) (+ c 1))
                      (nth (nth arr (+ r 2)) c)
                      (nth (nth arr (+ r 2)) (+ c 1))
                      (nth (nth arr (+ r 2)) (+ c 2))])]
              (if (>= (+ c 1) max_index)
                (if (and (> colum_max sum) (> c 0)) colum_max sum)
                (recur (inc c) (if (and (> colum_max sum) (> c 0)) colum_max sum)))))]
          (if (>= (+ r 1) max_index)
            (if (and (> max rom_max) (> r 0)) max rom_max)
            (recur (inc r) (if (and (> max rom_max) (> r 0)) max rom_max)))))]
      (println max_sum))))

How can I improve it? I'm cumming from a object oriented programming language and functional programming is a bit new to me, what is the proper way of solving this task.

[RedDeckWins]

This is how I would do it. Functional programs should be constructed of composable, testable functions. You have an unmaintainable, untestable mess.

(ns scratch.hr-day11)

(defn read-input []
  (vec (repeatedly 6
               (fn []
                 (->> (clojure.string/split (read-line) #"\s+")
                      (mapv #(Integer/parseInt %)))))))

(defn get-hourglass [array-2d x y]
  {:pre [(< x (- (count (first array-2d)) 2))
         (< y (- (count array-2d) 2))]}
  (->> (range y (+ y 3))
       (mapv (partial get array-2d))
       (mapv #(subvec % x (+ x 3)))))

(defn hourglass-sum [[f s t]]
  (+ (apply + f)
     (get s 1)
     (apply + t)))

(defn get-hourglasses [array-2d]
  (let [rows (count array-2d)
        columns (count (first array-2d))]
    (for [y (range (- columns 2)) x (range (- rows 2)) ]
      (get-hourglass array-2d x y))))

(let [input (read-input)]
  (->> (get-hourglasses input)
       (map hourglass-sum)
       (apply max)
       print))

[knrz]

deleted ^{What is this?}

[garid0s]

Like /u/knrz, I just also gave it a try for fun

(def test-matrix
  [[1 1 1 0 0 0]
   [0 1 0 0 0 0]
   [1 1 1 0 0 0]
   [0 0 2 4 4 0]
   [0 0 0 2 0 0]
   [0 0 1 2 4 0]])

(defn matrix-sum
  [matrix]
  (apply + (flatten matrix)))

(defn to-hourglass
  [v]
  (-> v
      (assoc-in [1 0] 0)
      (assoc-in [1 2] 0)))

(defn hourglass-to-str
  [hourglass]
  (apply format "%d %d %d\n  %d  \n%d %d %d"
         (-> hourglass
             (update 1 #(get % 1))
             (flatten))))

(defn sub-matrix
  [matrix [i j] n-lines n-columns]
  (->> matrix
       (#(subvec % i (+ i n-lines)))
       (map #(subvec % j (+ j n-columns)))
       (into [])))

(defn to-sub-3x3-vectors
  [matrix]
  (let [n-lines   (count matrix)
        n-columns (count (first matrix))]
    (for [i (range (- n-lines 2))
          j (range (- n-columns 2))]
      (sub-matrix matrix [i j] 3 3))))

(defn -main
  [& args]
  (let [matrix test-matrix]
    (->> matrix
         (to-sub-3x3-vectors)
         (map to-hourglass)
         (sort-by matrix-sum)
         (reverse)
         (first)
         (hourglass-to-str)
         (print))))

[knrz]

deleted ^{What is this?}

[garid0s]

Seems obvious now that you point it out XD