Ok, ho guardato Rich. Talk interessante, non mi ha dato l’impressione di un rant static Vs dynamic. Mi sembra che effettivamente stia rivalutando s/nilable in Clojure e guardando agli altri linguaggi per ispirazione/critica. Mi piace l’idea di distinguere tra attributes <- schemas <- selections (penulitma slide) e rivedere tipi come tree di cui “dichiaro” cosa mi interessa (zippers-selectors? mmh).

Mi chiedo anche: a questo punto ci potranno essere common/ontologies (tipo ::people ::automotive etc.) che qualcuno mantiene e contegono tutto riguardo ad un grupppo di taxonomies? Tanto poi io piglio quello che mi serve.

buongiorno 🙂

@reborg mmm interessante. Oggi me lo guardo anche io

qualcuno ha suggerimenti su come scrivere un algoritmo tipo questo?

(defn longest-subseq-rec
  [s]
  (loop [subseq s
         curr 0
         tot 0]

    (let [curr-max (max curr tot)]
      (if (empty? subseq)
        curr-max
        (if (= :w (first subseq))
          (recur (rest subseq) (inc curr) curr-max)
          (recur (rest subseq) 0 curr-max))))))

(longest-subseq-rec [:w :w :l :w :w :w])
;; => 3

(longest-subseq-rec [:w :w :w :w :l :w :w :w])
;; => 4

che funziona gia' cosi ricorsivamente, ma mi domandavo se non c'e' un modo di farlo con reduce & compagni

ah ho trovato un modo 😄 (apply max (map count (filter #(= #{:w} (set %)) (partition-by identity [:w :w :l :l :w :w :w]))))

che scritto cosi e' piu' umano

(->> [:w :w :l :l :w :w :w]
              (partition-by identity)
              (filter #(= #{:w} (set %)))
              (map count)
              (apply max))

Un altra cosa simile però adesso, data una sequenza tipo [1 2 10 4 7 30] vorrei trovare il massimo incremento consecutivo

Che in quel caso sarebbe 26 per esempio

Qui mi sa devo andare di ricorsione

definisci "massimo incremento consecutivo"?

non riesco a capire 26 da dove esce

30 - 7 = 26? 😁

30 - 4

Data una sequenza crescente la differenza tra il primo e l'ultimo

Prendendo la differenza più grande

Ti stiamo facendo i compiti o l’interview?

Nessuno dei due 😄

Fa parte del progetto elo di cui parlavo l'altra sera

Il primo era per calcolare il longest streak di vittorie

Questo per l'incremento più alto

Vabbeh in qualche modo ce la faccio usando la ricorsione, mi da che il caso degli incrementi non posso fare magie con partition map e compagnia

https://github.com/AndreaCrotti/elo/blob/master/src/cljs/elo/league_detail/handlers.cljs

Alla fine di quel file

comunque, forse puoi far qualcosa con reductions, vedi (reductions (fn [[max prev succ] itm] [max succ itm]) [0 0 0] [1 2 10 4 7 30] )

Ah magico direi

Ok grazie ci provo

non sono sicuro al 100% ma mi sembra che concettualmente si possa fare portandoti dietro il current max, l’elemento precedente ed il successivo.