Fork me on GitHub
#clojure-italy
<
2017-08-16
>
richiardiandrea07:08:36

Background anche a te! :)

reborg08:08:07

Era Bergamo... 😄

manuel08:08:20

e io che avevo pensato a Baldur's Gate

reborg08:08:07

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

kors09:08:03

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

kors09:08:53

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

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

kors09:08:23

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 😄

reborg09:08:11

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

reborg09:08:18

comunque si alla fine non mi lamento 🙂

mbarbieri12:08:49

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

mbarbieri21:08:32

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

kors23:08:53

(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
non credo sia tanto diverso. Il volume di codice più o meno è là. Forse mi sembra giusto più chiaro. Sono meno funzioni

kors23:08:03

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