Clojurians
#clojure-italy
<
2017-08-16
>

This page is not created by, affiliated with, or supported by Slack Technologies, Inc.

richiardiandrea07:08:36

Background anche a te! :)

kors08:08:56

Non essendo un grande esperto di emacs non ho ancora capito se ha ispector, debugger... In realtà lavorando in clojure rarissimamente ho avuto bisogno del debugger. Lo vorrei usare anche per altri linguaggi, tipo java appunto :smile:

reborg08:08:07

Era Bergamo... :smile:

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 :smile:

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 :slightly_smiling_face:

mbarbieri12:08:49

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

reborg18:08:13

@mbarbieri interessante?

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