BG!

Background anche a te! :)

Era Bergamo... 😄

e io che avevo pensato a Baldur's Gate

non ho idea di quando trovero' il tempo di guardare gli euroclojure talks

@reborg che ne pensi di denormalizzare i dati per colonne, righe, diagonali, e poi ridurre per ottenere il vincitore?

Piu o meno è quel che fai. Pensavo di trasfomare:

[[nil :o   :x] 
[nil :x   :o] 
[:x  nil nil]]

'([nil :o   :x] [nil :x :o] [:x nil nil] [nil nil :x] [:o :x nil] [:x :o nil] [:nil :x nil] [:x :x :x])

Ci sarebbe comunque pochissima differenza. In pausa ti faccio il codice. Forse risparmi una funzione. Comunque prova a farlo in java poi vediamo quanto è "tanto" il codice 😄

@kors credo sia lo stesso approccio, all ritorna la lista delle righe, colonne e le 2 diagonali

comunque si alla fine non mi lamento 🙂

@reborg io intanto ho guardato quello di Alex Miller, si accettano consigli per il prossimo da guardare 🙂

@mbarbieri interessante?

abbastanza, mostra cosa hanno cominciare a fare per implementare quello che diceva Rich nel keynote "Spec-ulation"

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

(defn columns
      [game]
      (map #((doseq [x (range 1 (count %))] (nth % x)))) game)

(defmacro retrieve-diag [map]
          `(into [] (map #(get (last %) (first %)) ~map)))

(defn diags
      [game]
      (let [concat-game (into [] (concat game game))
            progression (range 0 3)
            diags-1 (retrieve-diag (zipmap progression game))
            diags-2 (retrieve-diag (zipmap progression (reverse game)))]
           [diags-1 diags-2]))

(defn win?
      [game what]
      (let [complete-game (concat game (columns game) (diags game))
            reduced-game (map #(apply = what %) complete-game)]
           (some true? reduced-game)))

(win? game :x)                                             ; true
(win? game :o)                                             ; nil

Risolvendo "progression" che è hardcoded forse risolve anche matrici più grandi