Add scripts to verify exercises

Author: ErikSchierboom

bin/verify-exercises

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+# Synopsis:
+# Verify that each exercise's example/exemplar solution passes the tests.
+# You can either verify all exercises or a single exercise.
+
+# Example: verify all exercises
+# bin/verify-exercises
+
+# Example: verify single exercise
+# bin/verify-exercises two-fer
+
+set -eo pipefail
+
+die() { echo "$*" >&2; exit 1; }
+
+required_tool() {
+    command -v "${1}" >/dev/null 2>&1 ||
+        die "${1} is required but not installed. Please install it and make sure it's in your PATH."
+}
+
+required_tool bb
+
+bb test.clj "$@"

bin/verify-exercises-in-docker

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+
+# Synopsis:
+# Verify that each exercise's example/exemplar solution passes the tests
+# using the track's test runner Docker image.
+# You can either verify all exercises or a single exercise.
+
+# Example: verify all exercises in Docker
+# bin/verify-exercises-in-docker
+
+# Example: verify single exercise in Docker
+# bin/verify-exercises-in-docker two-fer
+
+set -eo pipefail
+
+die() { echo "$*" >&2; exit 1; }
+
+required_tool() {
+    command -v "${1}" >/dev/null 2>&1 ||
+        die "${1} is required but not installed. Please install it and make sure it's in your PATH."
+}
+
+required_tool docker
+
+copy_example_or_examplar_to_solution() {
+    jq -c '[.files.solution, .files.exemplar // .files.example] | transpose | map({src: .[1], dst: .[0]}) | .[]' .meta/config.json \
+    | while read -r src_and_dst; do
+        cp "$(jq -r '.src' <<< "${src_and_dst}")" "$(jq -r '.dst' <<< "${src_and_dst}")"
+    done
+}
+
+pull_docker_image() {
+    # shellcheck disable=SC1083
+    docker pull exercism/clojure-test-runner ||
+        die $'Could not find the `exercism/clojure-test-runner` Docker image.\nCheck the test runner docs at https://exercism.org/docs/building/tooling/test-runners for more information.'
+}
+
+run_tests() {
+    local slug
+    slug="${1}"
+
+    # shellcheck disable=SC1083
+    docker run \
+        --rm \
+        --network none \
+        --read-only \
+        --mount type=bind,src="${PWD}",dst=/solution \
+        --mount type=bind,src="${PWD}",dst=/output \
+        --mount type=tmpfs,dst=/tmp \
+        exercism/clojure-test-runner "${slug}" /solution /output
+    jq -e '.status == "pass"' "${PWD}/results.json" >/dev/null 2>&1
+}
+
+verify_exercise() {
+    local dir
+    local slug
+    local tmp_dir
+    dir=$(realpath "${1}")
+    slug=$(basename "${dir}")
+    tmp_dir=$(mktemp -d -t "exercism-verify-${slug}-XXXXX")
+
+    echo "Verifying ${slug} exercise..."
+
+    (
+        trap 'rm -rf "$tmp_dir"' EXIT    # remove tempdir when subshell ends
+        cp -r "${dir}/." "${tmp_dir}"
+        cd "${tmp_dir}"
+
+        copy_example_or_examplar_to_solution
+        run_tests "${slug}"
+    )
+}
+
+verify_exercises() {
+    local exercise_slug
+    exercise_slug="${1}"
+
+    shopt -s nullglob
+    count=0
+    for exercise_dir in ./exercises/{concept,practice}/${exercise_slug}/; do
+        if [[ -d "${exercise_dir}" ]]; then
+            verify_exercise "${exercise_dir}"
+            ((++count))
+        fi
+    done
+    ((count > 0)) || die 'no matching exercises found!'
+}
+
+pull_docker_image
+
+exercise_slug="${1:-*}"
+verify_exercises "${exercise_slug}"

exercises/concept/annalyns-infiltration/src/annalyns_infiltration.clj

@@ -3,19 +3,24 @@
 (defn can-fast-attack?
   "Returns true if a fast-attack can be made, false otherwise."
   [knight-awake?]
-  )
+  (not knight-awake?))
 
 (defn can-spy?
   "Returns true if the kidnappers can be spied upon, false otherwise."
   [knight-awake? archer-awake? prisoner-awake?]
-  )
+  (or knight-awake? archer-awake? prisoner-awake?))
 
 (defn can-signal-prisoner?
   "Returns true if the prisoner can be signalled, false otherwise."
   [archer-awake? prisoner-awake?]
-  )
+  (and (not archer-awake?)
+       prisoner-awake?))
 
 (defn can-free-prisoner?
   "Returns true if prisoner can be freed, false otherwise."
   [knight-awake? archer-awake? prisoner-awake? dog-present?]
-  )
+  (or (and (not knight-awake?)
+           (not archer-awake?)
+           prisoner-awake?)
+      (and (not archer-awake?)
+           dog-present?)))

exercises/concept/bird-watcher/src/bird_watcher.clj

@@ -1,22 +1,21 @@
 (ns bird-watcher)
 
-(def last-week 
-  )
+(def last-week [0 2 5 3 7 8 4])
 
 (defn today [birds]
-  )
+  (peek birds))
 
 (defn inc-bird [birds]
-  )
+  (update birds (dec (count birds)) inc))
 
 (defn day-without-birds? [birds]
-  )
+  (not (every? pos? birds)))
 
 (defn n-days-count [birds n]
-  )
+  (reduce + (take n birds)))
 
 (defn busy-days [birds]
-  )
+  (count (filter #(>= % 5) birds)))
 
 (defn odd-week? [birds]
-  )
+  (= birds [1 0 1 0 1 0 1]))

exercises/concept/card-games/src/card_games.clj

@@ -4,41 +4,47 @@
   "Takes the current round number and returns 
    a `list` with that round and the _next two_."
   [n]
-  )
+  (list n (inc n) (+ n 2)))
 
-(defn concat-rounds 
+(defn concat-rounds
   "Takes two lists and returns a single `list` 
    consisting of all the rounds in the first `list`, 
    followed by all the rounds in the second `list`"
   [l1 l2]
-  )
+  (concat l1 l2))
 
-(defn contains-round? 
+(defn contains-round?
   "Takes a list of rounds played and a round number.
    Returns `true` if the round is in the list, `false` if not."
   [l n]
-  )
+  (boolean (some #{n} l)))
 
 (defn card-average
   "Returns the average value of a hand"
   [hand]
-  )
+  (double (/ (apply + hand) (count hand))))
 
 (defn approx-average?
   "Returns `true` if average is equal to either one of:
   - Take the average of the _first_ and _last_ number in the hand.
   - Using the median (middle card) of the hand."
   [hand]
-  )
+  (or (= (card-average hand) (double (/ (+ (first hand) (last hand)) 2)))
+      (= (card-average hand) (double (nth hand (int (/ (count hand) 2.0)))))))
 
 (defn average-even-odd?
   "Returns true if the average of the cards at even indexes 
    is the same as the average of the cards at odd indexes."
   [hand]
-  )
+  (let [evens (map #(nth hand %) (range 1 (count hand) 2))
+        odds (map #(nth hand %) (range 0 (count hand) 2))]
+    (= (double (/ (apply + evens) (count evens)))
+       (double (/ (apply + odds) (count odds))))))
 
 (defn maybe-double-last
   "If the last card is a Jack (11), doubles its value
    before returning the hand."
   [hand]
-  )
+  (if (= 11 (last hand))
+    (concat (butlast hand) '(22))
+    hand))

exercises/concept/cars-assemble/src/cars_assemble.clj

@@ -1,12 +1,21 @@
 (ns cars-assemble)
 
+(def default-rate 221)
+
+(defn success-rate [speed]
+  (cond (= speed 10) 0.77
+        (= speed 9) 0.8
+        (>= speed 5) 0.9
+        :else 1.0))
+
 (defn production-rate
   "Returns the assembly line's production rate per hour,
    taking into account its success rate"
   [speed]
-  )
+  (* (* default-rate speed)
+     (success-rate speed)))
 
 (defn working-items
   "Calculates how many working cars are produced per minute"
   [speed]
-  )
+  (int (quot (production-rate speed) 60)))

exercises/concept/coordinate-transformation/src/coordinate_transformation.clj

@@ -1,26 +1,41 @@
 (ns coordinate-transformation)
 
-(defn translate2d 
+(defn translate2d
   "Returns a function making use of a closure to
    perform a repeatable 2d translation of a coordinate pair."
   [dx dy]
-  )
+  (fn [x y] [(+ dx x) (+ dy y)]))
 
-(defn scale2d 
+(defn scale2d
   "Returns a function making use of a closure to
    perform a repeatable 2d scale of a coordinate pair."
   [sx sy]
-  )
+  (fn [x y] [(* sx x) (* sy y)]))
 
 (defn compose-transform
   "Create a composition function that returns a function that 
    combines two functions to perform a repeatable transformation."
   [f g]
-  )
+  (fn [x y]
+    (let [f-result (f x y)]
+      (g (first f-result) (last f-result)))))
 
 (defn memoize-transform
   "Returns a function that memoizes the last result.
    If the arguments are the same as the last call,
    the memoized result is returned."
   [f]
-  )
+  (let [mem (atom {:last-x nil
+                   :last-y nil
+                   :last-result nil})]
+    (fn [& args]
+      (if-let [e (and
+                  (= (first args) (:last-x @mem))
+                  (= (last args) (:last-y @mem))
+                  (:last-result @mem))]
+        e
+        (let [ret (apply f args)]
+          (swap! mem assoc :last-x (first args))
+          (swap! mem assoc :last-y (last args))
+          (swap! mem assoc :last-result ret)
+          ret)))))

exercises/concept/date-parser/src/date_parser.clj

@@ -1,39 +1,58 @@
 (ns date-parser)
 
-(def day)
-(def month)
-(def year)
+(def day "\\d{1,2}")
+(def month "\\d{1,2}")
+(def year "\\d{4}")
 
-(def days)
+(def days "Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday")
 
 (defn day-names [s]
-  )
+  (re-matches (re-pattern days) s))
 
-(def months)
+(def months "January|February|March|April|May|June|July|August|September|October|November|December")
 
 (defn month-names [s]
-  )
+  (re-matches (re-pattern months) s))
 
 (defn capture-month [s]
-  )
+  (let [matcher (re-matcher (re-pattern (str "(?<month>" month ")")) s)]
+    (when (.matches matcher)
+      {:month (.group matcher "month")})))
 
 (defn capture-day [s]
-  )
+  (let [matcher (re-matcher (re-pattern (str "(?<day>" day ")")) s)]
+    (when (.matches matcher)
+      {:day (.group matcher "day")})))
 
 (defn capture-year [s]
-  )
+  (let [matcher (re-matcher (re-pattern (str "(?<year>" year ")")) s)]
+    (when (.matches matcher)
+      {:year (.group matcher "year")})))
 
 (defn capture-month-name [s]
-  )
+  {:month-name   (first (re-find (re-pattern (str "(?<month>" months ")")) s))})
 
 (defn capture-day-name [s]
-  )
+  {:day-name (first (re-find (re-pattern (str "(?<day>" days ")")) s))})
 
 (defn capture-numeric-date [s]
-  )
+  (let [matcher (re-matcher (re-pattern (str "(?<day>" day ")/(?<month>" month ")/(?<year>" year ")")) s)]
+    (when (.matches matcher)
+      {:day (.group matcher "day")
+       :month (.group matcher "month")
+       :year (.group matcher "year")})))
 
 (defn capture-month-name-date [s]
-  )
+  (let [matcher (re-matcher (re-pattern (str "(?<month>" months ") (?<day>" day "), (?<year>" year ")")) s)]
+    (when (.matches matcher)
+      {:month-name (.group matcher "month")
+       :day (.group matcher "day")
+       :year (.group matcher "year")})))
 
 (defn capture-day-month-name-date [s]
-  )
+  (let [matcher (re-matcher (re-pattern (str "(?<dayname>" days "), (?<month>" months ") (?<day>" day "), (?<year>" year ")")) s)]
+    (when (.matches matcher)
+      {:day-name (.group matcher "dayname")
+       :month-name (.group matcher "month")
+       :day (.group matcher "day")
+       :year (.group matcher "year")})))