(def start-board [[1 2 3]
                      [4 5 6]
                      [7 8 9]])

(defn print-board! [board]
  (println)
  (doseq [row board]
    (println row)))

(defn winner? [rows]
  (or (some #(every? (fn [c] (= c \x)) %) rows)
      (some #(every? (fn [c] (= c \o)) %) rows)))

(defn transpose [m]
  (apply mapv vector m))

(defn game-won? [board]
  (let [winner-rows? (winner? board)
        columns (transpose board)
        winner-col? (winner? columns)
        diagonal (map-indexed (fn [i row] (nth row i)) board)
        winner-diagonal (winner? [diagonal])
        anti-diagonal (reverse (map-indexed (fn [i row] (nth row i)) (reverse board)))
        winner-anti-diagonal (winner? [anti-diagonal])]
    (or winner-rows? winner-col? winner-diagonal winner-anti-diagonal)))

(defn board-full? [board]
  (every? char? (flatten board)))

(defn legal-move? [board move]
  (and (<= 1 move 9)
       (integer? (get-in board [(int (Math/ceil (quot (dec move) 3))) (mod (dec move) 3)]))))

(defn make-move [board move turn]
  (update-in board [(int (Math/ceil (quot (dec move) 3))) (mod (dec move) 3)] (constantly turn)))

(def next-turn {\x \o
                \o \x})

(defn get-move! [turn]
  (printf "%s's turn. Please select a square\n" turn)
  (println "___________")
  (Integer/parseInt (read-line)))

(defn run-game []
  (loop [board start-board
         turn \x]
    (print-board! board)
    (cond 
      (game-won? board) (format "%s is the WINNER" (next-turn turn))
      (board-full? board) "DRAW"
      :else (let [move (get-move! turn)]
                  (if (legal-move? board move)
                    (recur (make-move board move turn) (next-turn turn))
                    (do (println "Please select a valid square")
                        (recur board turn)))))))

I think this is cool and not spammy, especially since you posted the code in a reply. There is also #C053PTJE6, just FYI.

(defn winner? [rows]
  (or (some #(every? #{\x} %) rows)
      (some #(every? #{\o} %) rows)))

(mapv #(%1 %2) [[1 2 3]
                [4 5 6]
                [7 8 9]] (range 3))
=> [1 5 9]

(mapv #(%1 %2) [[1 2 3]
                [4 5 6]
                [7 8 9]] [2 1 0])
=> [3 5 7]

(defn move->yx [n]
  (let [d (dec n)]
    [(quot d 3) (mod d 3)]))

Thank you very much for your feedback! I use this approach for the diagonal and anti-diagonal because i had some thought that i might want to extend the board size in the future. I've used your suggestion for legal-move and moved the repeated code into a new function. But i might have to refactor this anyways if i make it possible to change the board size Thank you again :)

The code looks pretty good/idiomatic to me.

user=> (type "a")
java.lang.String
user=>

(Character/isUpperCase \a)

is there any function to type cast to char ?

user=> (->> (clojure.reflect/reflect Character) :members (filter #(= 'isUpperCase (:name %))) (map :parameter-types))
([char] [int])
user=>

user=> (first "a")
\a
user=> (nth "a" 0)
\a
user=>

Don't think of it as casting though, a String is not castable to a char, a String is a list of Chars, it's like if you said if we can cast a List of int to an int, it doesn't make logical sense. So start thinking of a String like a collection of Characters, a String of one element is a Collection of one Character.

user=> '#(%)
(fn* [p1__2#] (p1__2#))
user=>

if #(+ % %) is the same as (fn [x] (+ x x)) then what is #(+ %) then what is #(+) then what is #(%)

You mean #(%) is trying to treat % as a function?

Hmm… makes sense the error is also indicating that class java.lang.Long cannot be cast to class clojure.lang.IFn 😞 probably should’ve read that carefully.

This confused many of us at first! Also watch out for e.g. (map #([%]) (range 3)) which, for the same reason, does not do what one might expect.

That won't work ... Try (map identity [1 2 3]) which is not anonymous or (map #(do %) [1 2 3]) which uses anonymous function form but is not idiomatic. This #(%) is not allowed as % is not a function, but in this case it is an integer. So for instance you can't do this (1) and expect it to execute, since 1 is not a function.

The trick you're looking for is:

#(do %)
#(do [%])
#(do (println %) (* 2 %))