trackler 2.0.0.8 → 2.0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b7fb0f61f9c8eeb36237b4d667c18c9a637d465
-  data.tar.gz: 24aa9513475689221e00ddad5585c67e64047858
+  metadata.gz: 8b7052e1aa34da1303db05680e424c5e292e29be
+  data.tar.gz: 74176fc6e34d0e6a9549d763f537418d2ed523f8
 SHA512:
-  metadata.gz: 116e406aaeb2ddd1cd16ce8aee2774f44974b5694a6270b5953edc510e1536c3d75edaf2777c1c41fe4dd6e6b3b56c86231fcb19c15f154a3293d69feea6aeac
-  data.tar.gz: ce7b0811e5696f6c036afa6d51306636af107bd5c892bc91a2623726d3eaa28e7421609aadc711776c418bf6ed953a0437542300b590f5a4f80f6e81bbc15e59
+  metadata.gz: 1f950ed2480962dab6eb855c6b332fbbe8d9de480b0990db072ada4986bac5fa84461212eb34cfeb0ce9b13c1d05d309ec485c0d665ab6329c3aa4cebe63ef43
+  data.tar.gz: 90e9f0168b2d5e463abec0a322b5e942162dc2db55f90577a90ee5527e1977ca52de495fa8e0b388ae60108d980c9851fb015deccb7c97253a90f9d1a548d114

data/common/exercises/bob/canonical-data.json

@@ -1,13 +1,4 @@
 {
-   "#": [
-      "For 'gibberish', some languages generate a random strings.",
-      "Similarly for 'prolonged silence' and 'alternate silence' some",
-      "languages generate random length strings of a whitespace character.",
-	  "",
-      "The \\u escaped 'other' whitespace (in case you don't have all of",
-	  "these codes memorized) are b: vertical tab, a0: non-breaking space,",
-	  "and 2002: en-space."
-   ],
    "cases": [
       {
          "description": "stating something",
@@ -74,16 +65,6 @@
          "input": "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!",
          "expected": "Whoa, chill out!"
       },
-      {
-         "description": "shouting with umlauts",
-         "input": "ÜMLÄÜTS!",
-         "expected": "Whoa, chill out!"
-      },
-      {
-         "description": "calmly speaking with umlauts",
-         "input": "ÜMLäÜTS!",
-         "expected": "Whatever."
-      },
       {
          "description": "shouting with no exclamation mark",
          "input": "I HATE YOU",
@@ -136,7 +117,7 @@
       },
       {
          "description": "other whitespace",
-         "input": "\n\r \t\u000b\u00a0\u2002",
+         "input": "\n\r \t",
          "expected": "Fine. Be that way!"
       },
       {

data/common/exercises/raindrops/canonical-data.json

@@ -1,74 +1,92 @@
 {
    "cases": [
       {
+         "description" : "the sound for 1 is 1",
          "number" : 1,
          "expected": "1"
       },
       {
+         "description" : "the sound for 3 is Pling",
          "number" : 3,
          "expected": "Pling"
       },
       {
+         "description" : "the sound for 5 is Plang",
          "number" : 5,
          "expected": "Plang"
       },
       {
+         "description" : "the sound for 7 is Plong",
          "number" : 7,
          "expected": "Plong"
       },
       {
+         "description" : "the sound for 6 is Pling as it has a factor 3",
          "number" : 6,
          "expected": "Pling"
       },
       {
+        "description" : "2 to the power 3 does not make a raindrop sound as 3 is the exponent not the base",
         "number" : 8,
         "expected": "8"
       },
       {
+         "description" : "the sound for 9 is Pling as it has a factor 3",
          "number" : 9,
          "expected": "Pling"
       },
       {
+         "description" : "the sound for 10 is Plang as it has a factor 5",
          "number" : 10,
          "expected": "Plang"
       },
       {
+         "description" : "the sound for 14 is Plong as it has a factor of 7",
          "number" : 14,
          "expected": "Plong"
       },
       {
+         "description" : "the sound for 15 is PlingPlang as it has factors 3 and 5",
          "number" : 15,
          "expected": "PlingPlang"
       },
       {
+         "description" : "the sound for 21 is PlingPlong as it has factors 3 and 7",
          "number" : 21,
          "expected": "PlingPlong"
       },
       {
+         "description" : "the sound for 25 is Plang as it has a factor 5",
          "number" : 25,
          "expected": "Plang"
       },
       {
+         "description" : "the sound for 27 is Pling as it has a factor 3",
          "number" : 27,
          "expected": "Pling"
       },
       {
+         "description" : "the sound for 35 is PlangPlong as it has factors 5 and 7",
          "number" : 35,
          "expected": "PlangPlong"
       },
       {
+         "description" : "the sound for 49 is Plong as it has a factor 7",
          "number" : 49,
          "expected": "Plong"
       },
       {
+         "description" : "the sound for 52 is 52",
          "number" : 52,
          "expected": "52"
       },
       {
+         "description" : "the sound for 105 is PlingPlangPlong as it has factors 3, 5 and 7",
          "number" : 105,
          "expected": "PlingPlangPlong"
       },
       {
+        "description" : "the sound for 3125 is Plang as it has a factor 5",
         "number" : 3125,
         "expected": "Plang"
       }

data/common/exercises/sublist/canonical-data.json

@@ -92,5 +92,10 @@
 		"list_one": [1, 2, 3],
 		"list_two": [3, 2, 1],
 		"expectation": "unequal"
+	}, {
+		"description": "same digits but different numbers",
+		"list_one": [1, 0, 1],
+		"list_two": [10, 1],
+		"expectation": "unequal"
 	}]
 }

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.0.8"
+  VERSION = "2.0.0.9"
 end

data/tracks/clojure/config.json

@@ -280,6 +280,11 @@
       "difficulty": 1,
       "slug": "isogram",
       "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "pig-latin",
+      "topics": []
     }
   ]
 }

data/tracks/clojure/exercises/pig-latin/project.clj

@@ -0,0 +1,4 @@
+(defproject pig-latin "0.1.0-SNAPSHOT"
+  :description "pig latin exercise."
+  :url "https://github.com/exercism/xclojure/tree/master/exercises/pig-latin"
+  :dependencies [[org.clojure/clojure "1.8.0"]])

data/tracks/clojure/exercises/pig-latin/src/example.clj

@@ -0,0 +1,49 @@
+(ns pig-latin
+  (:require [clojure.string :as str]))
+
+(defn- starts-with-any [prefixes word]
+  (some (partial str/starts-with? word) prefixes))
+
+(defn- starts-with-vowel-like? [word]
+  (starts-with-any #{"yt" "xr"} word))
+
+(defn- starts-with-vowel? [word]
+  (starts-with-any #{"a" "e" "i" "o" "u"} word))
+
+(defn- starts-with-two-letter-prefix? [word]
+  (starts-with-any #{"ch" "qu" "th"} word))
+
+(defn- starts-with-three-letter-prefix? [word]
+  (starts-with-any #{"thr" "sch"} word))
+
+(defn- starts-with-qu-and-preceeding-constanant? [word]
+  (and (not (starts-with-vowel? word))
+       (str/starts-with? (subs word 1) "qu")))
+
+(defn- rotate [word n]
+  (str (subs word n) (subs word 0 n)))
+
+(defn- append-ay [word]
+  (str word "ay"))
+
+(defn- translate-word [word]
+  (cond
+    (or (starts-with-vowel? word)
+        (starts-with-vowel-like? word))
+    (append-ay word)
+
+    (or
+     (starts-with-three-letter-prefix? word)
+     (starts-with-qu-and-preceeding-constanant? word))
+    (append-ay (rotate word 3))
+
+    (starts-with-two-letter-prefix? word)
+    (append-ay (rotate word 2))
+
+    :else
+    (append-ay (rotate word 1))))
+
+(defn translate [words]
+  (->> (str/split words #" ")
+       (map translate-word)
+       (str/join " ")))

data/tracks/clojure/exercises/pig-latin/test/pig_latin_test.clj

@@ -0,0 +1,92 @@
+(ns pig-latin-test
+  (:require [clojure.test :refer [deftest is]]
+            pig-latin))
+
+;; ay is added to words that start with vowels
+
+(deftest word-beginning-with-a
+  (is (= "appleay"
+         (pig-latin/translate "apple"))))
+
+(deftest word-beginning-with-e
+  (is (= "earay"
+         (pig-latin/translate "ear"))))
+
+(deftest word-beginning-with-i
+  (is (= "iglooay"
+         (pig-latin/translate "igloo"))))
+
+(deftest word-beginning-with-o
+  (is (= "objectay"
+         (pig-latin/translate "object"))))
+
+(deftest word-beginning-with-u
+  (is (= "underay"
+         (pig-latin/translate "under"))))
+
+(deftest word-beginning-with-a-vowel-and-followed-by-a-qu
+  (is (= "equalay"
+         (pig-latin/translate "equal"))))
+
+;; first letter and ay are moved to the end of words that start with consonants
+
+(deftest word-beginning-with-p
+  (is (= "igpay"
+       (pig-latin/translate "pig"))))
+
+(deftest word-beginning-with-k
+  (is (= "oalakay"
+       (pig-latin/translate "koala"))))
+
+(deftest word-beginning-with-y
+  (is (= "ellowyay"
+       (pig-latin/translate "yellow"))))
+
+(deftest word-beginning-with-x
+  (is (= "enonxay"
+       (pig-latin/translate "xenon"))))
+
+(deftest word-beginning-with-q-without-a-following-u
+  (is (= "atqay"
+         (pig-latin/translate "qat"))))
+
+;; some letter clusters are treated like a single consonant
+
+(deftest word-beginning-with-ch
+  (is (= "airchay"
+       (pig-latin/translate "chair"))))
+
+(deftest word-beginning-with-qu
+  (is (= "eenquay"
+       (pig-latin/translate "queen"))))
+
+(deftest word-beginning-with-qu-and-a-preceding-consonant
+  (is (= "aresquay"
+       (pig-latin/translate "square"))))
+
+(deftest word-beginning-with-th
+  (is (= "erapythay"
+       (pig-latin/translate "therapy"))))
+
+(deftest word-beginning-with-thr
+  (is (= "ushthray"
+       (pig-latin/translate "thrush"))))
+
+(deftest word-beginning-with-sch
+  (is (= "oolschay"
+       (pig-latin/translate "school"))))
+
+;;  some letter clusters are treated like a single vowel
+
+(deftest word-beginning-with-yt
+  (is (= "yttriaay"
+       (pig-latin/translate "yttria"))))
+
+(deftest word-beginning-with-xr
+  (is (= "xrayay"
+       (pig-latin/translate "xray"))))
+
+;; phrases are translated
+(deftest a-whole-phrase
+  (is (= "ickquay astfay unray"
+       (pig-latin/translate "quick fast run"))))

data/tracks/clojure/exercises/robot-name/src/example.clj

@@ -1,19 +1,16 @@
 (ns robot-name)
 
-(defn robot []
-  {:name (atom "")})
-
-(def random (java.util.Random.))
-(def letters (map char (range 65 91)))
-(defn generate-name []
+(def ^:private random (java.util.Random.))
+(def ^:private letters (map char (range 65 91)))
+(defn- generate-name []
   (str (apply str (take 2 (shuffle letters)))
        (+ 100 (.nextInt random 899))))
 
+(defn robot []
+  (atom {:name (generate-name)}))
+
 (defn robot-name [robot]
-  (let [n @(:name robot)]
-    (if (= "" n)
-        (swap! (:name robot) #(str %1 (generate-name)))
-        n)))
+  (:name @robot))
 
 (defn reset-name [robot]
-  (swap! (:name robot) (fn [_] "")))
+  (swap! robot assoc :name (generate-name)))

data/tracks/clojure/exercises/robot-name/test/robot_name_test.clj

@@ -2,25 +2,30 @@
   (:require [clojure.test :refer [deftest is testing]]
             robot-name))
 
-(def ^:private robbie (robot-name/robot))
-(def ^:private clutz  (robot-name/robot))
-
 (deftest robot-name
-  (testing "robot-name"
-    (is (re-seq #"[A-Z]{2}\d{3}" (robot-name/robot-name robbie))
-        "name matches expected pattern")
-    (is (= (robot-name/robot-name robbie) (robot-name/robot-name robbie))
-        "name is persistent")
-    (is (not= (robot-name/robot-name clutz) (robot-name/robot-name robbie))
-        "different robots have different names")))
+  (let [a-robot (robot-name/robot)
+        its-name (robot-name/robot-name a-robot)]
+    (testing "robot-name"
+      (is (re-seq #"[A-Z]{2}\d{3}" its-name)
+          "name matches expected pattern")
+      (is (= its-name (robot-name/robot-name a-robot))
+          "name doesn't change until you reset it")
+      (is (not= its-name (-> (robot-name/robot) robot-name/robot-name))
+          "different robots have different names"))))
 
 (deftest reset-name
-  (testing "reset-name"
-    (let [original-name (robot-name/robot-name robbie)]
-      (robot-name/reset-name robbie)
-      (is (re-seq #"[A-Z]{2}\d{3}" (robot-name/robot-name robbie))
+  (let [a-robot (robot-name/robot)
+        its-original-name (robot-name/robot-name a-robot)
+        its-new-name (do (robot-name/reset-name a-robot)
+                         (robot-name/robot-name a-robot))]
+
+    (testing "reset-name"
+      (is (re-seq #"[A-Z]{2}\d{3}" its-new-name)
           "new name matches expected pattern")
-      (is (= (robot-name/robot-name robbie) (robot-name/robot-name robbie))
-          "new name is persistent")
-      (is (not= original-name (robot-name/robot-name robbie))
-          "new name is different from old name"))))
+      (is (not= its-original-name its-new-name)
+          "new name is different from old name")
+      (is (= its-new-name (robot-name/robot-name a-robot))
+          "new name doesn't change until you reset it")
+      (is (not= its-new-name (do (robot-name/reset-name a-robot)
+                                 (robot-name/robot-name a-robot)))
+          "new names are different each time"))))

data/tracks/crystal/config.json

@@ -118,6 +118,12 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "forth",
+      "difficulty": 3,
+      "topics": [
+      ]
     }
   ],
   "deprecated": [

data/tracks/crystal/exercises/acronym/spec/acronym_spec.cr

@@ -2,31 +2,31 @@ require "spec"
 require "../src/*"
 
 describe "Acronym" do
-  it "tests basic" do
+  it "does basic" do
     Acronym.abbreviate("Portable Network Graphics").should eq("PNG")
   end
 
-  it "tests lowercase words" do
+  pending "does lowercase words" do
     Acronym.abbreviate("Ruby on Rails").should eq("ROR")
   end
 
-  it "tests camelcase" do
+  pending "does camelcase" do
     Acronym.abbreviate("HyperText Markup Language").should eq("HTML")
   end
 
-  it "tests punctuation" do
+  pending "does punctuation" do
     Acronym.abbreviate("First In, First Out").should eq("FIFO")
   end
 
-  it "tests all caps words" do
+  pending "does all caps words" do
     Acronym.abbreviate("PHP: Hypertext Preprocessor").should eq("PHP")
   end
 
-  it "tests non-acronym all caps word" do
+  pending "does non-acronym all caps word" do
     Acronym.abbreviate("GNU Image Manipulation Program").should eq("GIMP")
   end
 
-  it "tests hyphenated" do
+  pending "does hyphenated" do
     Acronym.abbreviate("Complementary metal-oxide semiconductor").should eq("CMOS")
   end
 end

data/tracks/crystal/exercises/forth/spec/forth_spec.cr

@@ -0,0 +1,198 @@
+require "spec"
+require "../src/*"
+
+describe "Forth" do
+  it "empty input results in empty stack" do
+    Forth.evaluate("").should eq([] of Int32)
+  end
+
+  pending "numbers just get pushed onto the stack" do
+    Forth.evaluate("1 2 3 4 5").should eq([1, 2, 3, 4, 5])
+  end
+
+  pending "all non-word characters are separators" do
+    Forth.evaluate("1\u{0}2\u{13}3\n4\r5 6\t7").should eq([1, 2, 3, 4, 5, 6, 7])
+  end
+
+  pending "can add two numbers" do
+    Forth.evaluate("1 2 +").should eq([3])
+  end
+
+  pending "errors if there is nothing on the stack" do
+    expect_raises do
+      Forth.evaluate("+")
+    end
+  end
+
+  pending "errors if there is only one value on the stack" do
+    expect_raises do
+      Forth.evaluate("1 +")
+    end
+  end
+
+  pending "can subtract two numbers" do
+    Forth.evaluate("3 4 -").should eq([-1])
+  end
+
+  pending "errors if there is nothing on the stack" do
+    expect_raises do
+      Forth.evaluate("-")
+    end
+  end
+
+  pending "errors if there is only one value on the stack" do
+    expect_raises do
+      Forth.evaluate("1 -")
+    end
+  end
+
+  pending "can multiply two numbers" do
+    Forth.evaluate("2 4 *").should eq([8])
+  end
+
+  pending "errors if there is nothing on the stack" do
+    expect_raises do
+      Forth.evaluate("*")
+    end
+  end
+
+  pending "errors if there is only one value on the stack" do
+    expect_raises do
+      Forth.evaluate("1 *")
+    end
+  end
+
+  pending "can divide two numbers" do
+    Forth.evaluate("12 3 /").should eq([4])
+  end
+
+  pending "performs integer division" do
+    Forth.evaluate("8 3 /").should eq([2])
+  end
+
+  pending "errors if dividing by zero" do
+    expect_raises do
+      Forth.evaluate("4 0 /")
+    end
+  end
+
+  pending "errors if there is nothing on the stack" do
+    expect_raises do
+      Forth.evaluate("/")
+    end
+  end
+
+  pending "errors if there is only one value on the stack" do
+    expect_raises do
+      Forth.evaluate("1 /")
+    end
+  end
+
+  pending "addition and subtraction" do
+    Forth.evaluate("1 2 + 4 -").should eq([-1])
+  end
+
+  pending "multiplication and division" do
+    Forth.evaluate("2 4 * 3 /").should eq([2])
+  end
+
+  pending "copies the top value on the stack" do
+    Forth.evaluate("1 DUP").should eq([1, 1])
+  end
+
+  pending "is case-insensitive" do
+    Forth.evaluate("1 2 Dup").should eq([1, 2, 2])
+  end
+
+  pending "errors if there is nothing on the stack" do
+    expect_raises do
+      Forth.evaluate("dup")
+    end
+  end
+
+  pending "removes the top value on the stack if it is the only one" do
+    Forth.evaluate("1 drop").should eq([] of Int32)
+  end
+
+  pending "removes the top value on the stack if it is not the only one" do
+    Forth.evaluate("1 2 drop").should eq([1])
+  end
+
+  pending "errors if there is nothing on the stack" do
+    expect_raises do
+      Forth.evaluate("drop")
+    end
+  end
+
+  pending "swaps the top two values on the stack if they are the only ones" do
+    Forth.evaluate("1 2 swap").should eq([2, 1])
+  end
+
+  pending "swaps the top two values on the stack if they are not the only ones" do
+    Forth.evaluate("1 2 3 swap").should eq([1, 3, 2])
+  end
+
+  pending "errors if there is nothing on the stack" do
+    expect_raises do
+      Forth.evaluate("swap")
+    end
+  end
+
+  pending "errors if there is only one value on the stack" do
+    expect_raises do
+      Forth.evaluate("1 swap")
+    end
+  end
+
+  pending "copies the second element if there are only two" do
+    Forth.evaluate("1 2 over").should eq([1, 2, 1])
+  end
+
+  pending "copies the second element if there are more than two" do
+    Forth.evaluate("1 2 3 over").should eq([1, 2, 3, 2])
+  end
+
+  pending "errors if there is nothing on the stack" do
+    expect_raises do
+      Forth.evaluate("over")
+    end
+  end
+
+  pending "errors if there is only one value on the stack" do
+    expect_raises do
+      Forth.evaluate("1 over")
+    end
+  end
+
+  pending "can consist of built-in words" do
+    Forth.evaluate(": dup-twice dup dup ;1 dup-twice").should eq([1, 1, 1])
+  end
+
+  pending "execute in the right order" do
+    Forth.evaluate(": countup 1 2 3 ;countup").should eq([1, 2, 3])
+  end
+
+  pending "can override other user-defined words" do
+    Forth.evaluate(": foo dup ;: foo dup dup ;1 foo").should eq([1, 1, 1])
+  end
+
+  pending "can override built-in words" do
+    Forth.evaluate(": swap dup ;1 swap").should eq([1, 1])
+  end
+
+  pending "can consist of arbitrary characters such as Unicode characters" do
+    Forth.evaluate(": € 220371 ; €").should eq([220371])
+  end
+
+  pending "cannot redefine numbers" do
+    expect_raises do
+      Forth.evaluate(": 1 2 ;")
+    end
+  end
+
+  pending "errors if executing a non-existent word" do
+    expect_raises do
+      Forth.evaluate("foo")
+    end
+  end
+end