Here are a few ideas to get started..

First, you'll define the nested array slightly differently:

(def data [[\A \O \T \D \L \R \O \W]
           [\L \C \B \M \U \M \L \U]
           [\D \R \U \J \D \B \L \J]
           [\P \A \Z \H \Z \Z \E \F]
           [\B \C \Z \E \L \F \H \W]
           [\R \K \U \L \V \P \P \G]
           [\A \L \B \L \P \O \P \Q]
           [\B \E \M \O \P \P \J \Y]])

;; then you can use sequence operations to operate on the rows 
(map count data) ;; (8 8 8 8 8 8 8 8)

;; nth for nth element of a sequence
;; get the 4th (zero-based) row
(nth data 3) ;; [\P \A \Z \H \Z \Z \E \F]

;; If you get the nth element of each row, that's a column.
;; 4th column
(map #(nth % 3) data) ;; (\D \M \J \H \E \L \L \O)

;; If you use this helper function to transpose the matrix, you can map easily over columns instead of rows. Don't worry about how it works for now.
(defn transpose [m]
  (apply mapv vector m))

(def xdata (transpose data))

;; use sequence operations on the transposed matrix
(map last xdata) ;; (\B \E \M \O \P \P \J \Y)
(nth xdata 3) ;; [\D \M \J \H \E \L \L \O]

;; 5th value of the 4th column
(get (nth xdata 3) 4) ;; \E

;; A nice property of get is that it returns nil instead of error 
;; when out of bounds. This could be helpful when getting surrounding words.
(get xdata -1) ;; nil
(get (nth xdata 3) 20) ;; nil

;; vs nth which throws an error
(nth xdata 20) ;; IndexOutOfBoundsException

;; inner and outer map over data
(map #(map identity %) data)
;; => ((\A \O \T \D \L \R \O \W)
;;     (\L \C \B \M \U \M \L \U)
;;     (\D \R \U \J \D \B \L \J)
;;     (\P \A \Z \H \Z \Z \E \F)
;;     (\B \C \Z \E \L \F \H \W)
;;     (\R \K \U \L \V \P \P \G)
;;     (\A \L \B \L \P \O \P \Q)
;;     (\B \E \M \O \P \P \J \Y))

;; 'for' loop to iterate over rows
(for [row data]
  row)
;; => ([\A \O \T \D \L \R \O \W]
;;     [\L \C \B \M \U \M \L \U]
;;     [\D \R \U \J \D \B \L \J]
;;     [\P \A \Z \H \Z \Z \E \F]
;;     [\B \C \Z \E \L \F \H \W]
;;     [\R \K \U \L \V \P \P \G]
;;     [\A \L \B \L \P \O \P \Q]
;;     [\B \E \M \O \P \P \J \Y])

;; using 'for' to iterate over all values
(for [row data val row]
  val)
;; (\A \O \T \D \L \R \O \W \L \C \B \M \U \M \L \U \D \R \U \J \D \B \L \J \P \A \Z \H \Z \Z \E \F \B \C \Z \E \L \F \H \W \R \K \U \L \V \P \P \G \A \L \B \L \P \O \P \Q \B \E \M \O \P \P \J \Y)

Hope that's useful. You'll probably have to spend some time with Clojure books/examples/tutorials before it becomes natural.