trackler 2.0.8.14 → 2.0.8.15

data/tracks/go/exercises/grade-school/grade_school_test.go

@@ -105,7 +105,7 @@ func TestNonExistantGrade(t *testing.T) {
 	s := New()
 	got := s.Grade(1)
 	if len(got) != 0 {
-		t.Errorf(`Get non-existant grade, got
+		t.Errorf(`Get non-existent grade, got
 %q
 expected
 []`, got)

data/tracks/go/exercises/hello-world/hello_example_test.go

@@ -0,0 +1,20 @@
+package greeting
+
+import "fmt"
+
+// ExampleHelloWorld() is an Example function. Examples are testable snippets of
+// Go code that are used for documenting, and verifying, the package API.
+// They may be present in some exercises to demonstrate the expected use of the
+// exercise API and can be run as part of a package's test suite
+//
+// When an Example test is run the data that is written to standard output is
+// compared to the data that comes after the "Output: " comment.
+//
+// So, below, the result of HelloWorld() is passed to standard output
+// using fmt.Println, and this is compared against the expected output; Hello, World!
+// If they are equal, the test passes.
+func ExampleHelloWorld() {
+	h := HelloWorld()
+	fmt.Println(h)
+	// Output: Hello, World!
+}

data/tracks/go/exercises/minesweeper/minesweeper_test.go

@@ -94,7 +94,7 @@ var validBoards = []string{
 | |
 +-+`,
 
-	// 1x1 sqaure with 1 bomb
+	// 1x1 square with 1 bomb
 	`
 +-+
 |*|

data/tracks/go/exercises/pov/pov_test.go

@@ -259,10 +259,13 @@ func (tc testCase) testResult(got, want []string, msg string, t *testing.T) {
 	t.FailNow()
 }
 
-func TestConstruction(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestConstruction(t *testing.T) {
 	for _, tc := range testCases {
 		got := tc.graph().ArcList()
 		want := tc.arcStrings

data/tracks/java/exercises/pangram/src/example/java/{Pangrams.java → PangramChecker.java}

@@ -1,11 +1,13 @@
 import java.util.Arrays;
 import java.util.stream.Collectors;
 
-public class Pangrams {
+public class PangramChecker {
     private static final int alphaLength = 26;
 
-    public static boolean isPangram(String input){
-        return Arrays.stream(input.replaceAll("[^a-zA-Z]","").toLowerCase().split(""))
+    public boolean isPangram(String input) {
+        return Arrays.stream(input.replaceAll("[^a-zA-Z]", "")
+                .toLowerCase()
+                .split(""))
                 .collect(Collectors.toSet())
                 .size() == alphaLength;
     }

data/tracks/java/exercises/pangram/src/main/java/PangramChecker.java

@@ -0,0 +1,6 @@
+public class PangramChecker {
+
+    public boolean isPangram(String input) {
+        throw new UnsupportedOperationException("Method has not been implemented yet.");
+    }
+}

data/tracks/java/exercises/pangram/src/test/java/PangramCheckerTest.java

@@ -0,0 +1,82 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class PangramCheckerTest {
+    private PangramChecker pangramChecker;
+
+    @Before
+    public void setup() {
+        pangramChecker = new PangramChecker();
+    }
+
+
+    @Test
+    public void emptySentenceIsNotPangram() {
+        assertFalse(pangramChecker.isPangram(""));
+    }
+
+    @Ignore
+    @Test
+    public void pangramWithOnlyLowerCaseLettersIsRecognizedAsPangram() {
+        assertTrue(pangramChecker.isPangram("the quick brown fox jumps over the lazy dog"));
+    }
+
+    @Ignore
+    @Test
+    public void phraseMissingCharacterXIsNotPangram() {
+        assertFalse(pangramChecker.isPangram("a quick movement of the enemy will jeopardize five gunboats"));
+    }
+
+    @Ignore
+    @Test
+    public void anotherPhraseMissingCharacterXIsNotPangram() {
+        assertFalse(pangramChecker.isPangram("the quick brown fish jumps over the lazy dog"));
+    }
+
+    @Ignore
+    @Test
+    public void pangramWithUnderscoresIsRecognizedAsPangram() {
+        assertTrue(pangramChecker.isPangram("\"the_quick_brown_fox_jumps_over_the_lazy_dog\""));
+    }
+
+    @Ignore
+    @Test
+    public void pangramWithNumbersIsRecognizedAsPangram() {
+        assertTrue(pangramChecker.isPangram("\"the 1 quick brown fox jumps over the 2 lazy dogs\""));
+    }
+
+    @Ignore
+    @Test
+    public void phraseWithMissingLettersReplacedByNumbersIsNotPangram() {
+        assertFalse(pangramChecker.isPangram("\"7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog\""));
+    }
+
+    @Ignore
+    @Test
+    public void pangramWithMixedCaseAndPunctuationIsRecognizedAsPangram() {
+        assertTrue(pangramChecker.isPangram("\"Five quacking Zephyrs jolt my wax bed.\""));
+    }
+
+    @Ignore
+    @Test
+    public void pangramWithNonAsciiCharactersIsRecognizedAsPangram() {
+        assertTrue(pangramChecker.isPangram("Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich."));
+    }
+
+
+    @Ignore
+    @Test
+    public void panagramInAlphabetOtherThanAsciiIsNotRecognizedAsPangram() {
+        assertFalse(pangramChecker.isPangram("Широкая электрификация южных губерний даст мощный толчок подъёму сельского хозяйства."));
+    }
+
+    @Ignore
+    @Test
+    public void upperAndLowerCaseVersionsOfTheSameCharacterShouldNotBeCountedSeparately() {
+        assertFalse(pangramChecker.isPangram("the quick brown fox jumped over the lazy FOX"));
+    }
+}

data/tracks/ocaml/exercises/run-length-encoding/test.ml

@@ -13,6 +13,10 @@ let encode_tests = [
      ae "2A3B4C" (encode "AABBBCCCC");
    "single characters mixed with repeated characters" >::
      ae "12WB12W3B24WB" (encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB");
+   "multiple whitespace mixed in string" >::
+     ae "2 hs2q q2w2 " (encode "  hsqq qww  ");
+   "lowercase characters" >::
+     ae "2a3b4c" (encode "aabbbcccc");
 ]
 
 let decode_tests = [
@@ -24,11 +28,15 @@ let decode_tests = [
      ae "AABBBCCCC" (decode "2A3B4C");
    "single characters with repeated characters" >::
      ae "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB" (decode "12WB12W3B24WB");
+   "multiple whitespace mixed in string" >::
+     ae "  hsqq qww  " (decode "2 hs2q q2w2 ");
+   "lower case string" >::
+     ae "aabbbcccc" (decode "2a3b4c");
 ]
 
 let consistency_tests = [
    "encode followed by decode gives original string" >::
-     ae "zzz ZZ  zZ" (decode (encode "zzz ZZ  zZ"));
+     ae "zzz ZZ  zZ" (decode "zzz ZZ  zZ");
 ]
 
 let () =

data/tracks/ocaml/tools/test-generator/src/parser.ml

@@ -35,7 +35,7 @@ let parse_single (text: string) (expected_key: string) (cases_key: string): (tes
   Result.return (Single ts)
 
 let is_suite (json: json) (cases_key: string) =
-  let ignorable_keys = ["exercise"; "version"; "methods"] in
+  let ignorable_keys = ["exercise"; "version"; "methods"; "comments"] in
   let keys = List.filter (keys json) ~f:(Fn.non (List.mem ignorable_keys)) in
   let keys = List.sort keys ~cmp:String.compare in
   not (List.is_empty keys || keys = [cases_key] || keys = ["#"; cases_key])

data/tracks/ocaml/tools/test-generator/src/special_cases.ml

@@ -38,11 +38,22 @@ let option_of_null (value: json): string = match value with
 | `String s -> "(Some \"" ^ s ^ "\")"
 | _ -> failwith "cannot handle this type"
 
+let is_empty_string (value: json): bool = match value with
+| `String s -> String.is_empty s
+| _ -> false
+
+let edit_connect_expected = function
+| `String "X" -> "(Some X)"
+| `String "O" -> "(Some O)"
+| `String "" -> "None"
+| x -> failwith "Bad json value in connect " ^ json_to_string x
+
 let edit_expected ~(stringify: json -> string) ~(slug: string) ~(value: json) = match slug with
 | "hamming" -> optional_int ~none:(-1) value
 | "all-your-base" -> optional_int_list value
 | "say" -> optional_int_or_string ~none:(-1) value
 | "phone-number" -> option_of_null value
+| "connect" -> edit_connect_expected value
 | _ -> stringify value
 
 let edit_say (ps: (string * json) list) =
@@ -58,11 +69,10 @@ let edit_all_your_base (ps: (string * json) list): (string * string) list =
   | (k, v) -> (k, json_to_string v) in
   List.map ps ~f:edit
 
-let two_elt_list_to_tuple (j: json): string = match j with
-| `List [`Int x1; `Int x2] -> sprintf "(%d,%d)" x1 x2
-| _ -> failwith "two element list expected, but got " ^ (json_to_string j)
- 
 let edit_dominoes (ps: (string * json) list): (string * string) list =
+  let two_elt_list_to_tuple (j: json): string = match j with
+  | `List [`Int x1; `Int x2] -> sprintf "(%d,%d)" x1 x2
+  | _ -> failwith "two element list expected, but got " ^ (json_to_string j) in 
   let edit (p: (string * json)) = match p with
   | ("input", `List j) -> ("input", "[" ^ (List.map ~f:two_elt_list_to_tuple j |> String.concat ~sep:"; ") ^ "]")
   | (k, v) -> (k, json_to_string v) in
@@ -79,6 +89,4 @@ let expected_key_name slug = match slug with
 | "dominoes" -> "can_chain"
 | _ -> "expected"
 
-let cases_name slug = match slug with
-| "luhn" -> "valid"
-| _ -> "cases"
+let cases_name _slug = "cases"

data/tracks/python/exercises/list-ops/example.py

@@ -1,13 +1,13 @@
 def map_clone(function, xs):
-    return (function(elem) for elem in xs)
+    return [function(elem) for elem in xs]
 
 
 def length(xs):
-    return sum(1 for x in xs)
+    return sum(1 for _ in xs)
 
 
 def filter_clone(function, xs):
-    return (x for x in xs if function(x))
+    return [x for x in xs if function(x)]
 
 
 def reverse(xs):
@@ -23,14 +23,14 @@ def append(xs, y):
 
 
 def foldl(function, xs, acc):
-    if(len(xs) == 0):
+    if len(xs) == 0:
         return acc
     else:
         return foldl(function, xs[1:], function(acc, xs[0]))
 
 
 def foldr(function, xs, acc):
-    if(len(xs) == 0):
+    if len(xs) == 0:
         return acc
     else:
         return function(xs[0], foldr(function, xs[1:], acc))
@@ -39,7 +39,7 @@ def foldr(function, xs, acc):
 def flat(xs):
     out = []
     for item in xs:
-        if isinstance(item, (list, tuple)):
+        if isinstance(item, list):
             out.extend(flat(item))
         else:
             out.append(item)

data/tracks/python/exercises/list-ops/list_ops_test.py

@@ -9,34 +9,28 @@ class ListOpsTest(unittest.TestCase):
     # tests for map
     def test_map_square(self):
         self.assertEqual(
-            (1, 4, 9, 16, 25, 36, 49, 64, 81, 100),
-            tuple(list_ops.map_clone(
-                lambda x: x**2, (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
-            )
-        )
+            [1, 4, 9, 16, 25, 36, 49, 64, 81, 100],
+            list_ops.map_clone(
+                lambda x: x**2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
 
     def test_map_cube(self):
         self.assertEqual(
-            (-1, 8, -27, 64, -125, 216, -343, 512, -729, 1000),
-            tuple(list_ops.map_clone(
-                lambda x: x**3, (-1, 2, -3, 4, -5, 6, -7, 8, -9, 10))
-            )
-        )
+            [-1, 8, -27, 64, -125, 216, -343, 512, -729, 1000],
+            list_ops.map_clone(
+                lambda x: x**3, [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]))
 
     def test_map_absolute(self):
         self.assertEqual(
-            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10),
-            tuple(list_ops.map_clone(
-                lambda x: abs(x), (-1, 2, -3, 4, -5, 6, -7, 8, -9, 10))
-            )
-        )
+            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+            list_ops.map_clone(
+                lambda x: abs(x), [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]))
 
     def test_map_empty(self):
-        self.assertEqual([], list(list_ops.map_clone(operator.index, [])))
+        self.assertEqual([], list_ops.map_clone(operator.index, []))
 
     # tests for length
     def test_pos_leng(self):
-        self.assertEqual(10, list_ops.length((-1, 2, -3, 4, -5, 6, -7, 8, -9, 10)))
+        self.assertEqual(10, list_ops.length([-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]))
 
     def test_empty_len(self):
         self.assertEqual(0, list_ops.length([]))
@@ -44,15 +38,13 @@ class ListOpsTest(unittest.TestCase):
     # tests for filter
     def test_filter_odd(self):
         self.assertEqual(
-            (1, 3, 5),
-            tuple(list_ops.filter_clone(lambda x: x % 2 != 0, [1, 2, 3, 4, 5, 6]))
-        )
+            [1, 3, 5],
+            list_ops.filter_clone(lambda x: x % 2 != 0, [1, 2, 3, 4, 5, 6]))
 
     def test_filter_even(self):
         self.assertEqual(
-            (2, 4, 6),
-            tuple(list_ops.filter_clone(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6]))
-        )
+            [2, 4, 6],
+            list_ops.filter_clone(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6]))
 
     # tests for reverse
     def test_reverse_small(self):
@@ -60,19 +52,17 @@ class ListOpsTest(unittest.TestCase):
 
     def test_reverse_mixed_types(self):
         self.assertEqual(
-            (1, "cat", 4.0, "xyz"),
-            list_ops.reverse(("xyz", 4.0, "cat", 1))
-        )
+            [1, "cat", 4.0, "xyz"],
+            list_ops.reverse(["xyz", 4.0, "cat", 1]))
 
     def test_reverse_empty(self):
-        self.assertEqual([], list_ops.reverse(()))
+        self.assertEqual([], list_ops.reverse([]))
 
     # tests for append
     def test_append_tuple(self):
         self.assertEqual(
             ["10", "python", "hello"],
-            list_ops.append(["10", "python"], "hello")
-        )
+            list_ops.append(["10", "python"], "hello"))
 
     def test_append_range(self):
         self.assertEqual([100, range(1000)], list_ops.append([100], range(1000)))
@@ -116,20 +106,15 @@ class ListOpsTest(unittest.TestCase):
     def test_concat_two(self):
         self.assertEqual(
             [1, 3, 5, 8, 9, 4, 5, 6],
-            list_ops.concat([1, 3, 5, 8], [9, 4, 5, 6])
-        )
+            list_ops.concat([1, 3, 5, 8], [9, 4, 5, 6]))
 
     def test_concat_nothing(self):
         self.assertEqual(
             ["orange", "apple", "banana"],
-            list_ops.concat(['orange', 'apple', 'banana'], None)
-        )
+            list_ops.concat(['orange', 'apple', 'banana'], None))
 
     def test_concat_empty(self):
-        self.assertEqual(
-            [],
-            list_ops.concat([], [])
-        )
+        self.assertEqual([], list_ops.concat([], []))
 
 
 if __name__ == '__main__':

data/tracks/typescript/.gitignore

@@ -6,6 +6,6 @@ bin/configlet
 bin/configlet.exe
 node_modules
 .idea
-.build
+build
 babel-output
 lintreport.json

data/tracks/typescript/config.json

@@ -88,6 +88,18 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "etl",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
+    {
+      "slug": "space-age",
+      "difficulty": 1,
+      "topics": [
+      ]
     },
       {
       "slug": "wordy",

data/tracks/typescript/exercises/etl/etl.example.ts

@@ -0,0 +1,16 @@
+
+function transform(input: {[key: string]: string[]}): {[key: string]: number} {
+    const phase1: {[key: string]: number} = {}
+
+    for ( const key in input) {
+        if (input.hasOwnProperty(key)) {
+            const value = input[key]
+            for (const each of value) {
+                phase1[each.toLowerCase()] = Number.parseInt(key, 10)
+            }
+        }
+    }
+    return phase1
+}
+
+export default transform