Hackerrank: battere i record

Question

Sto imparando Clojure e sono un rango n00b, cercando di imparare da libri e tutorial online (ma a volte sono preoccupato di prendere cattive abitudini o almeno non tutte le buone abitudini). Per esercizio ho eseguito il problema Breaking the Records su Hackerrank.

TL; descrizione del problema DR:

Per un elenco di punteggi (in ordine storico), conta il numero di volte in cui il punteggio migliore precedente è stato superato e il punteggio peggiore precedente è stato ridotto.

In un linguaggio iterativo è abbastanza facile scorrere l'elenco ; ma Clojure non esegue iterazioni e ho deciso di affrontare questo problema per esercitarvi a costruire una soluzione ricorsiva (tail end). Per renderlo più facile per me stesso, ho prima fatto una soluzione ricorsiva in Java, che poi ho tradotto. Tutto sommato, è una funzione ricorsiva abbastanza semplice senza intervento chirurgico a razzo.

Ovviamente il mio codice funziona, come mostrato dagli unit test inclusi. Le mie preoccupazioni sono tuttavia le seguenti:

• Quando vengono messi accanto al codice Java, i due sembrano abbastanza simili. Ho seguito la programmazione "idiomatica" di Clojure, o è solo una goffa "traslitterazione parola per parola"?
• Ci sono aree che avrebbero potuto essere più compatte e / o più facili da capire utilizzando diversi costrutti Clojure?

Il tuo contributo critico sarà molto apprezzato, anche per quanto riguarda il test unitario , poiché questa è probabilmente una parte importante della programmazione, che voglio imparare e praticare in parallelo.

Codice:

(ns hackerrank.breaking-records
  (:require [clojure.test :refer :all]))

(defrecord Record [min max countworse countbetter])

(defn recalc-record [rec newscore]
  (Record.
    (min newscore (:min rec))
    (max newscore (:max rec))
    (+ (:countworse rec) (if (> (:min rec) newscore) 1  0))
    (+ (:countbetter rec) (if (< (:max rec) newscore) 1  0))))

(defn accumulate [curr-record remaining-scores]
  (if (nil? (second remaining-scores))
    curr-record
    (recur (recalc-record curr-record (second remaining-scores)) (rest remaining-scores)))
)

(defn breaking-records [scores]
  (let [result (accumulate (Record. (first scores) (first scores) 0 0) scores)]
    (list (:countbetter result) (:countworse result))))

(deftest test-records
  (testing "edge cases"
    (is (= '(0 0) (breaking-records '())) "no games played yet")
    (is (= '(0 0) (breaking-records '(5))) "single game"))
  (testing "hackerrank examples"
    (is (= '(2 4) (breaking-records '(10 5 20 20 4 5 2 25 1))))
    (is (= '(4 0) (breaking-records '(3 4 21 36 10 28 35 5 24 42)))))
)

Answer 1

Ho riscritto la tua soluzione per utilizzare le funzionalità più tipiche di Clojure. Quando si esegue il loop dei dati e si deve tenere traccia dello stato accumulato, è difficile battere loop/recur. Un primo esempio:

(ns tst.demo.core
  (:use clojure.test))

(defn breaking-records
  [scores]
  ; this loop has 5 variables. Init all of them
  (loop [low         (first scores)
         high        (first scores)
         nworse      0
         nbetter     0
         score-pairs (partition 2 1 scores)]
    (if (empty? score-pairs)
      {:nbetter nbetter :nworse nworse}
      (let [curr-score-pair (first score-pairs)
            new-score       (second curr-score-pair)]
        ; start the next iteration with modified versions of the 5 loop vars
        (recur
          (min new-score low)
          (max new-score high)
          (if (< new-score low)
            (inc nworse)
            nworse)
          (if (< high new-score)
            (inc nbetter)
            nbetter)
          (rest score-pairs))))))

e unit test:

(deftest test-records
  (testing "edge cases"
    (is (= (breaking-records []) {:nbetter 0 :nworse 0}) "no games played yet")
    (is (= (breaking-records [5]) {:nbetter 0 :nworse 0}) "single game"))
  (testing "hackerrank examples"
    (is (= (breaking-records [10 5 20 20 4 5 2 25 1]) {:nbetter 2 :nworse 4}))
    (is (= (breaking-records [3 4 21 36 10 28 35 5 24 42]) {:nbetter 4 :nworse 0}))))

; ***** NOTE: it's much easier to use vectors like [1 2 3] instead of a quoted list `(1 2 3)

Si prega di consultare questo elenco di documentazione , in particolare. il Clojure CheatSheet. Inoltre, il progetto del modello nel suo insieme mostra come mi piace strutturare le cose. :)

La funzione che aiuta di più è partition. Vedi i documenti .

---

Leggero refactoring

Puoi semplificarlo un po 'e renderlo un po' più compatto utilizzando funzioni più specializzate come reducee cond->. Questa versione utilizza una mappa per mantenere lo stato e reduceper eseguire il ciclo:

(defn breaking-records
  [scores]
  (let [state-init     {:low     (first scores)
                        :high    (first scores)
                        :nworse  0
                        :nbetter 0}
        accum-stats-fn (fn [state score-pair]
                         ; Use map destructuring to pull out the 4 state variables
                         (let [{:keys [low high nworse nbetter]} state 
                               new-score (second score-pair)
                               state-new {:low     (min new-score low)
                                          :high    (max new-score high)
                                          :nworse  (cond-> nworse
                                                     (< new-score low) (inc))
                                          :nbetter (cond-> nbetter
                                                     (< high new-score) (inc))}]
                           state-new))
        state-final    (reduce accum-stats-fn
                         state-init
                         (partition 2 1 scores))
        result         (select-keys state-final [:nworse :nbetter])]
    result))