Hackerrank: Bicie rekordów

Question

Uczę się Clojure i mam w tym rangę n00b, próbując uczyć się z książek i samouczków online (ale czasami obawiam się, że wychwytuję złe nawyki lub przynajmniej nie wszystkie dobre nawyki). W ramach ćwiczenia rozwiązałem problem Breaking the Records na Hackerrank.

Opis problemu TL; DR:

Aby uzyskać listę wyników (w kolejności historycznej), policz, ile razy poprzedni najlepszy wynik został przekroczony, a także poprzedni najgorszy wynik został podcięty.

W języku iteracyjnym dość łatwo jest po prostu iterować po liście ; ale Clojure nie wykonuje iteracji i postanowiłem zająć się tym problemem, aby poćwiczyć w konstruowaniu (końca) rozwiązania rekurencyjnego. Aby sobie to ułatwić, najpierw wykonałem rozwiązanie rekurencyjne w Javie, które następnie przetłumaczyłem. Podsumowując, jest to dość prosta funkcja rekurencyjna bez operacji rakietowej.

Oczywiście mój kod działa, o czym świadczą dołączone testy jednostkowe. Moje obawy są jednak następujące:

• Po umieszczeniu obok kodu Java, oba wyglądają dość podobnie. Czy postępowałem zgodnie z „idiomatycznym” programowaniem Clojure, czy jest to po prostu niezdarna „transliteracja słowo w słowo”?
• Czy są jakieś obszary, które mogłyby być bardziej zwarte i / lub łatwiejsze do zrozumienia przy użyciu różnych konstrukcji Clojure?

Twój krytyczny wkład będzie bardzo cenny - w tym w odniesieniu do testów jednostkowych , ponieważ jest to prawdopodobnie ważna część programowania, której chcę się uczyć i ćwiczyć równolegle.

Kod:

(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

Ponownie napisałem Twoje rozwiązanie, aby korzystało z bardziej typowych funkcji Clojure. Kiedy zapętlasz dane i musisz śledzić skumulowany stan, trudno jest go pokonać loop/recur. Pierwszy przykład:

(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))))))

i testy jednostkowe:

(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)

Proszę zapoznać się z listą dokumentacji , zwł. ściągawka Clojure. Ponadto projekt szablonu jako całość pokazuje, jak lubię układać rzeczy. :)

Najbardziej pomaga funkcja partition. Zobacz dokumentację .

---

Nieznaczna refaktoryzacja

Możesz go nieco uprościć i uczynić nieco bardziej kompaktowym, używając bardziej wyspecjalizowanych funkcji, takich jak reducei cond->. Ta wersja używa mapy do zatrzymania stanu i reducewykonania pętli:

(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))