trackler 2.0.8.43 → 2.0.8.44

data/tracks/go/gen/gen.go

@@ -26,11 +26,10 @@ import (
 //     └── xgo
 var dirMetadata string
 
-// dirProblem is the location that the test cases should be generated to.
-// This assumes that the generator script lives in the same directory as
-// the problem.
-// Falls back to the present working directory.
-var dirProblem string
+// dirExercise is the location that the test cases should be generated to.
+// This assumes that the generator script lives in the .meta directory within
+// the exercise directory. Falls back to the present working directory.
+var dirExercise string
 
 // Header tells how the test data was generated, for display in the header of cases_test.go
 type Header struct {
@@ -58,13 +57,14 @@ func init() {
 		dirMetadata = filepath.Join(path, "..", "..", "..", "x-common")
 	}
 	if _, path, _, ok := runtime.Caller(2); ok {
-		dirProblem = filepath.Join(path, "..")
+		dirExercise = filepath.Join(path, "..", "..")
 	}
-	if dirProblem == "" {
-		dirProblem = "."
+	if dirExercise == "" {
+		dirExercise = "."
 	}
 }
 
+// Gen generates the exercise cases_test.go file from the relevant canonical-data.json
 func Gen(exercise string, j interface{}, t *template.Template) error {
 	if dirMetadata == "" {
 		return errors.New("unable to determine current path")
@@ -116,7 +116,7 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
 		return err
 	}
 	// write output file for the Go test cases.
-	return ioutil.WriteFile(filepath.Join(dirProblem, "cases_test.go"), src, 0666)
+	return ioutil.WriteFile(filepath.Join(dirExercise, "cases_test.go"), src, 0666)
 }
 
 func getPath(jFile string) (jPath, jOrigin, jCommit string) {

data/tracks/purescript/config.json

@@ -115,6 +115,13 @@
       "topics": [
         "base conversion"
       ]
+    },
+    {
+      "slug": "binary-search",
+      "difficulty": 1,
+      "topics": [
+        "binary search"
+      ]
     }
   ],
   "deprecated": [

data/tracks/purescript/exercises/binary-search/bower.json

@@ -0,0 +1,16 @@
+{
+  "name": "binary-search",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-prelude": "^2.5.0"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^2.0.0",
+    "purescript-test-unit": "^10.1.0"
+  }
+}

data/tracks/purescript/exercises/binary-search/examples/src/BinarySearch.purs

@@ -0,0 +1,19 @@
+module BinarySearch
+  ( find
+  ) where
+
+import Prelude
+import Data.Array (length, (!!))
+import Data.Maybe (Maybe(Just, Nothing))
+
+find :: Int -> Array Int -> Maybe Int
+find i a = go 0 (length a - 1)
+  where go l h | l > h = Nothing
+        go l h =
+          let m = l + (h - l) / 2
+          in case a !! m of
+               Nothing -> Nothing
+               Just j | j == i    -> Just m
+                      | j < i     -> go (m + 1) h
+                      | otherwise -> go l (m - 1)
+

data/tracks/purescript/exercises/binary-search/src/BinarySearch.purs

@@ -0,0 +1,3 @@
+module BinarySearch
+  ( find
+  ) where

data/tracks/purescript/exercises/binary-search/test/Main.purs

@@ -0,0 +1,53 @@
+module Test.Main where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Data.Maybe (Maybe(..))
+import Test.Unit.Assert as Assert
+import Test.Unit (suite, test)
+import Test.Unit.Main (runTest)
+import BinarySearch (find)
+
+main :: Eff _ Unit
+main = runTest do
+  suite "BinarySearch.find" do
+
+    test "finds a value in an array with one element" $
+      Assert.equal (Just 0)
+                   (find 6 [6])
+
+    test "finds a value in the middle of an array" $
+      Assert.equal (Just 3)
+                   (find 6 [1,3,4,6,8,9,11])
+
+    test "finds a value at the beginning of an array" $
+      Assert.equal (Just 0)
+                   (find 1 [1,3,4,6,8,9,11])
+
+    test "finds a value at the end of an array" $
+      Assert.equal (Just 6)
+                   (find 11 [1,3,4,6,8,9,11])
+
+    test "finds a value in an array of odd length" $
+      Assert.equal (Just 9)
+                   (find 144 [1,3,5,8,13,21,34,55,89,144,233,377,634])
+
+    test "finds a value in an array of even length" $
+      Assert.equal (Just 5)
+                   (find 21 [1,3,5,8,13,21,34,55,89,144,233,377])
+
+    test "identifies that a value is not included in the array" $
+      Assert.equal Nothing
+                   (find 7 [1,3,4,6,8,9,11])
+
+    test "a value smaller than the array's smallest value is not included" $
+      Assert.equal Nothing
+                   (find 0 [1,3,4,6,8,9,11])
+
+    test "a value larger than the array's largest value is not included" $
+      Assert.equal Nothing
+                   (find 13 [1,3,4,6,8,9,11])
+
+    test "nothing is included in an empty array" $
+      Assert.equal Nothing
+                   (find 1 [])

data/tracks/python/config.json

@@ -380,6 +380,12 @@
       "topics": [
       ]
     },
+    {
+      "slug": "transpose",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
     {
       "slug": "poker",
       "difficulty": 1,

data/tracks/python/exercises/rectangles/rectangles_test.py

@@ -3,64 +3,91 @@ import unittest
 from rectangles import count
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class WordTest(unittest.TestCase):
-    def test_zero_area_1(self):
-        self.assertEqual(count(), 0)
+    def test_no_rows(self):
+        self.assertEqual(count([]), 0)
 
-    def test_zero_area_2(self):
-        lines = ""
-        self.assertEqual(count(lines), 0)
+    def test_no_columns(self):
+        self.assertEqual(count(['']), 0)
 
-    def test_empty_area(self):
-        lines = " "
-        self.assertEqual(count(lines), 0)
+    def test_no_rectangles(self):
+        self.assertEqual(count([' ']), 0)
 
     def test_one_rectangle(self):
-        lines = ["+-+",
-                 "| |",
-                 "+-+"]
+        lines = ['+-+',
+                 '| |',
+                 '+-+']
         self.assertEqual(count(lines), 1)
 
-    def test_two_rectangles_no_shared_parts(self):
-        lines = ["  +-+",
-                 "  | |",
-                 "+-+-+",
-                 "| |  ",
-                 "+-+  "]
+    def test_two_rectangles_without_shared_parts(self):
+        lines = ['  +-+',
+                 '  | |',
+                 '+-+-+',
+                 '| |  ',
+                 '+-+  ']
         self.assertEqual(count(lines), 2)
 
-    def test_five_rectangles_three_regions(self):
-        lines = ["  +-+",
-                 "  | |",
-                 "+-+-+",
-                 "| | |",
-                 "+-+-+"]
+    def test_five_rectangles_with_shared_parts(self):
+        lines = ['  +-+',
+                 '  | |',
+                 '+-+-+',
+                 '| | |',
+                 '+-+-+']
         self.assertEqual(count(lines), 5)
 
-    def test_incomplete_rectangles(self):
-        lines = ["  +-+",
-                 "    |",
-                 "+-+-+",
-                 "| | -",
-                 "+-+-+"]
+    def test_rectangle_of_height_1_is_counted(self):
+        lines = ['+--+',
+                 '+--+']
+        self.assertEqual(count(lines), 1)
+
+    def test_rectangle_of_width_1_is_counted(self):
+        lines = ['++',
+                 '||',
+                 '++']
+        self.assertEqual(count(lines), 1)
+
+    def test_1x1_square_is_counted(self):
+        lines = ['++',
+                 '++']
+        self.assertEqual(count(lines), 1)
+
+    def test_only_complete_rectangles_are_counted(self):
+        lines = ['  +-+',
+                 '    |',
+                 '+-+-+',
+                 '| | -',
+                 '+-+-+']
         self.assertEqual(count(lines), 1)
 
-    def test_complicated(self):
-        lines = ["+------+----+",
-                 "|      |    |",
-                 "+---+--+    |",
-                 "|   |       |",
-                 "+---+-------+"]
+    def test_rectangles_can_be_of_different_sizes(self):
+        lines = ['+------+----+',
+                 '|      |    |',
+                 '+---+--+    |',
+                 '|   |       |',
+                 '+---+-------+']
         self.assertEqual(count(lines), 3)
 
-    def test_not_so_complicated(self):
-        lines = ["+------+----+",
-                 "|      |    |",
-                 "+------+    |",
-                 "|   |       |",
-                 "+---+-------+"]
+    def test_corner_is_required_for_a_rectangle_to_be_complete(self):
+        lines = ['+------+----+',
+                 '|      |    |',
+                 '+------+    |',
+                 '|   |       |',
+                 '+---+-------+']
         self.assertEqual(count(lines), 2)
 
+    def test_large_input_with_many_rectangles(self):
+        lines = ['+---+--+----+',
+                 '|   +--+----+',
+                 '+---+--+    |',
+                 '|   +--+----+',
+                 '+---+--+--+-+',
+                 '+---+--+--+-+',
+                 '+------+  | |',
+                 '          +-+']
+        self.assertEqual(count(lines), 60)
+
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/python/exercises/transpose/example.py

@@ -0,0 +1,6 @@
+def transpose(input_lines):
+    lines = input_lines.split("\n")
+    zipped = map(list,
+                 [line.ljust(len(max(lines, key=len)))
+                  for line in lines])
+    return "\n".join("".join(line) for line in zip(*zipped)).strip()

data/tracks/python/exercises/transpose/transpose.py

@@ -0,0 +1,2 @@
+def transpose():
+    pass

data/tracks/python/exercises/transpose/transpose_test.py

@@ -0,0 +1,264 @@
+import unittest
+from transpose import transpose
+
+
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
+class TransposeTests(unittest.TestCase):
+    def test_empty_string(self):
+        input_line = ""
+        expected = ""
+        self.assertEqual(
+            transpose(input_line),
+            expected
+        )
+
+    def test_two_characters_in_a_row(self):
+        self.assertEqual(
+            transpose("A1"),
+            "\n".join(["A", "1"])
+        )
+
+    def test_two_characters_in_a_column(self):
+        self.assertEqual(
+            transpose("\n".join(["A", "1"])),
+            "A1"
+        )
+
+    def test_simple(self):
+        input_line = [
+            "ABC",
+            "123"
+        ]
+        expected = [
+            "A1",
+            "B2",
+            "C3"
+        ]
+
+        self.assertEqual(
+            transpose("\n".join(input_line)),
+            "\n".join(expected)
+        )
+
+    def test_single_line(self):
+        input_line = ["Single line."]
+        expected = [
+            "S",
+            "i",
+            "n",
+            "g",
+            "l",
+            "e",
+            " ",
+            "l",
+            "i",
+            "n",
+            "e",
+            "."
+        ]
+        self.assertEqual(
+            transpose("\n".join(input_line)),
+            "\n".join(expected)
+        )
+
+    def test_first_line_longer_than_second_line(self):
+        input_line = [
+            "The fourth line.",
+            "The fifth line."
+        ]
+        expected = [
+            "TT",
+            "hh",
+            "ee",
+            "  ",
+            "ff",
+            "oi",
+            "uf",
+            "rt",
+            "th",
+            "h ",
+            " l",
+            "li",
+            "in",
+            "ne",
+            "e.",
+            "."
+        ]
+        self.assertEqual(
+            transpose("\n".join(input_line)),
+            "\n".join(expected)
+        )
+
+    def test_second_line_longer_than_first_line(self):
+        input_line = [
+            "The first line.",
+            "The second line."
+        ]
+        expected = [
+            "TT",
+            "hh",
+            "ee",
+            "  ",
+            "fs",
+            "ie",
+            "rc",
+            "so",
+            "tn",
+            " d",
+            "l ",
+            "il",
+            "ni",
+            "en",
+            ".e",
+            " ."
+        ]
+        self.assertEqual(
+            transpose("\n".join(input_line)),
+            "\n".join(expected)
+        )
+
+    def test_square(self):
+        input_line = [
+            "HEART",
+            "EMBER",
+            "ABUSE",
+            "RESIN",
+            "TREND"
+        ]
+        expected = [
+            "HEART",
+            "EMBER",
+            "ABUSE",
+            "RESIN",
+            "TREND"
+        ]
+        self.assertEqual(
+            transpose("\n".join(input_line)),
+            "\n".join(expected)
+        )
+
+    def test_rectangle(self):
+        input_line = [
+            "FRACTURE",
+            "OUTLINED",
+            "BLOOMING",
+            "SEPTETTE"
+        ]
+        expected = [
+            "FOBS",
+            "RULE",
+            "ATOP",
+            "CLOT",
+            "TIME",
+            "UNIT",
+            "RENT",
+            "EDGE"
+        ]
+        self.assertEqual(
+            transpose("\n".join(input_line)),
+            "\n".join(expected)
+        )
+
+    def test_triangle(self):
+        input_line = [
+            "T",
+            "EE",
+            "AAA",
+            "SSSS",
+            "EEEEE",
+            "RRRRRR"
+        ]
+        expected = [
+            "TEASER",
+            " EASER",
+            "  ASER",
+            "   SER",
+            "    ER",
+            "     R"
+        ]
+        self.assertEqual(
+            transpose("\n".join(input_line)),
+            "\n".join(expected)
+        )
+
+    def test_many_lines(self):
+        input_line = [
+            "Chor. Two households, both alike in dignity,",
+            "In fair Verona, where we lay our scene,",
+            "From ancient grudge break to new mutiny,",
+            "Where civil blood makes civil hands unclean.",
+            "From forth the fatal loins of these two foes",
+            "A pair of star-cross'd lovers take their life;",
+            "Whose misadventur'd piteous overthrows",
+            "Doth with their death bury their parents' strife.",
+            "The fearful passage of their death-mark'd love,",
+            "And the continuance of their parents' rage,",
+            "Which, but their children's end, naught could remove,",
+            "Is now the two hours' traffic of our stage;",
+            "The which if you with patient ears attend,",
+            "What here shall miss, our toil shall strive to mend."
+        ]
+        expected = [
+            "CIFWFAWDTAWITW",
+            "hnrhr hohnhshh",
+            "o oeopotedi ea",
+            "rfmrmash  cn t",
+            ".a e ie fthow ",
+            " ia fr weh,whh",
+            "Trnco miae  ie",
+            "w ciroitr btcr",
+            "oVivtfshfcuhhe",
+            " eeih a uote  ",
+            "hrnl sdtln  is",
+            "oot ttvh tttfh",
+            "un bhaeepihw a",
+            "saglernianeoyl",
+            "e,ro -trsui ol",
+            "h uofcu sarhu ",
+            "owddarrdan o m",
+            "lhg to'egccuwi",
+            "deemasdaeehris",
+            "sr als t  ists",
+            ",ebk 'phool'h,",
+            "  reldi ffd   ",
+            "bweso tb  rtpo",
+            "oea ileutterau",
+            "t kcnoorhhnatr",
+            "hl isvuyee'fi ",
+            " atv es iisfet",
+            "ayoior trr ino",
+            "l  lfsoh  ecti",
+            "ion   vedpn  l",
+            "kuehtteieadoe ",
+            "erwaharrar,fas",
+            "   nekt te  rh",
+            "ismdsehphnnosa",
+            "ncuse ra-tau l",
+            " et  tormsural",
+            "dniuthwea'g t ",
+            "iennwesnr hsts",
+            "g,ycoi tkrttet",
+            "n ,l r s'a anr",
+            "i  ef  'dgcgdi",
+            "t  aol   eoe,v",
+            "y  nei sl,u; e",
+            ",  .sf to l   ",
+            "     e rv d  t",
+            "     ; ie    o",
+            "       f, r   ",
+            "       e  e  m",
+            "       .  m  e",
+            "          o  n",
+            "          v  d",
+            "          e  .",
+            "          ,"
+        ]
+        self.assertEqual(
+            transpose("\n".join(input_line)),
+            "\n".join(expected)
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()