tic_tac_toe.clj

(ns tic-tac-toe)

;; Calculate the columns indexes
(defn columns-indexes
  [side]
  (let [size (* side side)]
    (reduce
     (fn [m n]
       (conj m
             (take side (range n size side))))
     ()
     (range side))))


;; Calculate the rows indexes
(defn rows-indexes
  [side]
  (let [size (* side side)]
    (partition side
               (range 0 size))))


;; Calculate the diagonals indexes
(defn diagonals-indexes
  [side]
  (let [size (* side side)]
    (list
     (take side (range 0 size (inc side)))
     (take side (range (dec side) size (dec side))))))


;; Gather all the indexes
(defn get-indexes
  [side]
  (concat (columns-indexes side)
          (rows-indexes side)
          (diagonals-indexes side)))

;; Get all the values
(defn get-values-from-indexes
  [game indexes]
  (reduce
   (fn [m i]
     (conj m
           (map #(nth game %) i)))
   ()
   indexes))


(defn all-equals-to
  [v coll]
  (every? (partial = v) coll))


(defn has-won
  [game v]
  (let [fgame (flatten game)
        indexes (all-indexes (count game))
        values (get-values-from-indexes fgame indexes)]
    (some true?
          (map (partial all-equals-to v) values))))


(def game-3 [[nil :o   :x] 
             [nil :x   :o] 
             [:x  nil nil]])


(def game-5 [[:o nil nil :o :x] 
             [:o :o  nil :x :o]
             [:o nil :o  :x :o]
             [:o nil nil :o :o] 
             [:x nil nil :x :o]])

(has-won game-3 :x) ;;=> true
(has-won game-3 :o) ;;=> nil

(has-won game-5 :x) ;;=> nil
(has-won game-5 :o) ;;=> true